Problem: You are given an array s consisting of n integers.

You have to find any array t of length k such that you can cut out maximum number of copies of array t from array s.

Cutting out the copy of t means that for each element t_i of array t you have to find t_i in s and remove it from s. If for some t_i you cannot find such element in s, then you cannot cut out one more copy of t. The both arrays can contain duplicate elements.

For example, if s = [1, 2, 3, 2, 4, 3, 1] and k = 3 then one of the possible answers is t = [1, 2, 3]. This array t can be cut out 2 times. 

  * To cut out the first copy of t you can use the elements [1, \underline{2}, 3, 2, 4, \underline{3}, \underline{1}] (use the highlighted elements). After cutting out the first copy of t the array s can look like [1, 3, 2, 4]. 
  * To cut out the second copy of t you can use the elements [\underline{1}, \underline{3}, \underline{2}, 4]. After cutting out the second copy of t the array s will be [4]. 



Your task is to find such array t that you can cut out the copy of t from s maximum number of times. If there are multiple answers, you may choose any of them.

Input

The first line of the input contains two integers n and k (1 ≤ k ≤ n ≤ 2 ⋅ 10^5) — the number of elements in s and the desired number of elements in t, respectively.

The second line of the input contains exactly n integers s_1, s_2, ..., s_n (1 ≤ s_i ≤ 2 ⋅ 10^5).

Output

Print k integers — the elements of array t such that you can cut out maximum possible number of copies of this array from s. If there are multiple answers, print any of them. The required array t can contain duplicate elements. All the elements of t (t_1, t_2, ..., t_k) should satisfy the following condition: 1 ≤ t_i ≤ 2 ⋅ 10^5.

Examples

Input


7 3
1 2 3 2 4 3 1


Output


1 2 3 


Input


10 4
1 3 1 3 10 3 7 7 12 3


Output


7 3 1 3


Input


15 2
1 2 1 1 1 2 1 1 2 1 2 1 1 1 1


Output


1 1 

Note

The first example is described in the problem statement.

In the second example the only answer is [7, 3, 1, 3] and any its permutations. It can be shown that you cannot choose any other array such that the maximum number of copies you can cut out would be equal to 2.

In the third example the array t can be cut out 5 times.

Solution (in JAVA):

Solution:
/*
題目:
	給n個數字，要找出k個數字的集合T
	這個T集合的數字要在n個數字中出現最多次
	
輸入:
	10 4
	1 3 1 3 10 3 7 7 12 3
輸出:
	1 3 3 7

解法:
	給n個數字，求出現最多的次數
	如果不管需要k個數字組成T的話，最多一定是n，最少的次數是1
	所以有binary search找會出現幾次，然後算是否有足夠的數字k可以用
	如果足夠的話就繼續找大的，如果不足的話就往小的繼續找

*/
import java.util.*;
public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int k = sc.nextInt();
		
		// 把出現的次數存下來
		Map<Integer, Integer> map = new HashMap<Integer, Integer>();
		for(int i=0;i<n;i++) {
			int num = sc.nextInt();
			if(map.containsKey(num)) {
				map.put(num, map.get(num)+1);
			}
			else {
				map.put(num, 1);
			}
		}

		// binary search
		int left = 1, right = n, time=0;
		while(left+1<right) {
			// 假設可能出現的次數
			int mid = (right+left)/2;
			
			// 計算出現這麼多次是數字是否足夠
			int num = 0;
			for(Map.Entry<Integer, Integer> m: map.entrySet()) {
				num+=m.getValue()/mid;
			}
			if(num>=k) { // 如果足夠的話往更大的樹繼續找
				left = mid;
			}
			else { // 如果不夠的話找更小的
				right = mid;
			}
		}
		time = left; // 因為如果數字足夠大於k的話，left=mid，所以time要等於left
		
		for(Map.Entry<Integer, Integer> e: map.entrySet()) {
			if(e.getValue()>=time) {
				for(int j=1;j<=e.getValue()/time;j++) {
					System.out.print(e.getKey()+" ");
					k--;
					if(k<=0)
						break;
				}
			}
			if(k<=0)
				break;
		}
	}
}