struct Stack {
  unique_ptr<int[]> m_stack;
  int m_tos;
  size_t m_size;

  Stack() : m_stack(nullptr), m_tos(0), m_size(0) {}

  Stack(size_t size) : m_stack(new int[size]), m_tos(0), m_size(size) {}

  Stack &operator=(Stack &o) {
    m_stack.swap(o.m_stack);
    m_tos = o.m_tos;
    m_size = o.m_size;
    return *this;
  }

  bool push(const int &n) {
    if (m_tos == m_size) {
      return false;
    }
    m_stack[m_tos++] = n;
    return true;
  }
  bool pop(int &n) {
    if (m_tos == 0) {
      return false;
    }
    n = m_stack[--m_tos];
    return true;
  }
};

bool is_prime(int n) {
  if (n % 2 == 0 || n % 3 == 0 || n % 5 == 0 || n % 7 == 0) {
    return false;
  }

  int div{static_cast<int>(sqrt(n) + 1)};

  while (div > 7) {
    if (n % div == 0) {
      return false;
    }
    --div;
  }

  return true;
}

int next_prime(int n) {
  int p{n + 1};

  if (n < 2) {
    return 2;
  }

  if (n < 3) {
    return 3;
  }

  if (n < 5) {
    return 5;
  }

  if (n < 7) {
    return 7;
  }

  while (!is_prime(p)) {
    ++p;
  }

  return p;
}

vector<int> waiter(vector<int> number, int q) {
  vector<int> ans{};

  size_t n{number.size()};
  Stack a{n};
  Stack b{n};
  int s{};
  int p{};

  // push plates on A0
  for (const auto &n : number) {
    a.push(n);
  }

  for (int i{}; i < q; ++i) {
    Stack c{n};
    p = next_prime(p);

    while (a.pop(s)) {
      if (s % p == 0) {
        b.push(s); // Bi
      } else {
        c.push(s); // temp stack (Ai)
      }
    }
    a = c; // Ai

    // move Bi to ans
    while (b.pop(s)) {
      ans.push_back(s);
    }
  }
  while (a.pop(s)) {
    ans.push_back(s);
  }
  return ans;
}

vector<int> waiter(vector<int> number, int q) {
    
    vector<int> v{};
    stack<int> snumber;
    vector<int> output;
    
    for(auto a : number)
    {
        cout<<a<<" ";
        snumber.push(a);
    }
    auto getprimes =[](int q){
            deque<int> primes{};
            int num = 2;
            while (static_cast<int>(primes.size()) < q) {
                bool is_prime = true;
                for (int i = 2; i <= std::sqrt(num); ++i) {
                    if (num % i == 0) {
                        is_prime = false;
                        break;
                    }
                }
                if (is_prime) {
                    primes.push_back(num);
                }
                num++;
            }
            return primes;
    };
    deque<int> nprimes = getprimes(q);
    while (!nprimes.empty()) {
        int prime = nprimes.front();
        nprimes.pop_front();
            stack<int> a;
            stack<int> b;
            while(!snumber.empty())
            {
               int top = snumber.top();
               snumber.pop();
               if(top%prime==0)
                    b.push(top);
               else
                    a.push(top);
            }
            while(!b.empty())
            {
                int top = b.top();
                b.pop();
                output.push_back(top);
            }
            snumber=a;
    }
    
    while(!snumber.empty())
    {
        int top = snumber.top();
        snumber.pop();
        output.push_back(top);
    
    }
    return output;
}

def generate_primes(q):
    primes = []
    num = 2
    while len(primes) < q:
        is_prime = True
        for p in primes:
            if num % p == 0:
                is_prime = False
                break
        if is_prime:
            primes.append(num)
        num += 1
    return primes

def waiter(arr_p, q):
    primes = generate_primes(q)  
    answers = []

    for i in range(q):
        A, B = [], []
        prime = primes[i]

        while arr_p:
            plate = arr_p.pop()  
            if plate % prime == 0:
                B.append(plate)  
            else:
                A.append(plate)  

        answers.extend(reversed(B))
        arr_p = A 
    answers.extend(reversed(arr_p))

    return answers

if __name__ == '__main__':
    n, q = map(int, input().split())  
    arr_p = list(map(int, input().split()))  

    result = waiter(arr_p, q)  
    for i in result:
        print(i)

n, q = list(map(int, input().split()))

number = list(map(int, input().rstrip().split()))
length = len(number)

def get_primes(n, q):
    # Primes using Sieve of Eratosthenes
    primes = list()
    sieve = [True] * (n+1)
    for p in range(2, n+1):
        if sieve[p]:
            primes.append(p)
            for i in range(p, n+1 ,p):
                sieve[i] = False
        if len(primes) >= q: # we only need the first q prime numbers
            break
    return primes
    
primes = get_primes(max(number), q)
A = []
B= []
for _ in range(q):
    p = primes.pop(0) # the first prime number in the list
    for elem in number:
        if elem % p == 0: # check divisibility with prime number
            B.append(elem)
        else:
            A.append(elem)
            
    number = list(reversed(A)) # reverse the remainder elements for next iteration
    A = [] 

if len(B) == length:
    print(*B, sep="\n")
else:
    print(*(B + list(reversed(number))), sep="\n")    

def get_prime(n):
    if n < 2:
        return [];
    nums = [True]*(n+1)
    nums[0], nums[1] = False, False
    p = 2
    while(p*p<=n):
        if nums[p]:
            for i in range(p*p, n+1, p):
                nums[i] = False
        p+=1
    primes = [num for num, prime in enumerate(nums) if prime]
    return primes
        
primes = get_prime(10001)

def waiter(number, q):
    # Write your code here
    answers = []
    A = number
    
    for i in range(q):
        if not A:
            break
        prime = primes[i]
        B=[]
        new_A=[]
        for plate in reversed(A):
            if plate%prime==0:
                B.append(plate)
            else:
                new_A.append(plate)
        answers.extend(reversed(B))
        A=new_A
    answers.extend(reversed(A))
    return answers