We have a sequence of N \times K integers: X=(X_0,X_1,\cdots,X_{N \times K-1}). Its elements are represented by another sequence of N integers: A=(A_0,A_1,\cdots,A_{N-1}). For each pair i, j (0 \leq i \leq K-1,\ 0 \leq j \leq N-1), X_{i \times N + j}=A_j holds.

Snuke has an integer sequence s, which is initially empty. For each i=0,1,2,\cdots,N \times K-1, in this order, he will perform the following operation:

* If s does not contain X_i: add X_i to the end of s.
* If s does contain X_i: repeatedly delete the element at the end of s until s no longer contains X_i. Note that, in this case, we do not add X_i to the end of s.



Find the elements of s after Snuke finished the operations.

Constraints

* 1 \leq N \leq 2 \times 10^5
* 1 \leq K \leq 10^{12}
* 1 \leq A_i \leq 2 \times 10^5
* All values in input are integers.

Input

Input is given from Standard Input in the following format:


N K
A_0 A_1 \cdots A_{N-1}


Output

Print the elements of s after Snuke finished the operations, in order from beginning to end, with spaces in between.

Examples

Input

3 2
1 2 3


Output

2 3


Input

5 10
1 2 3 2 3


Output

3


Input

6 1000000000000
1 1 2 2 3 3


Output




Input

11 97
3 1 4 1 5 9 2 6 5 3 5


Output

9 2 6
import java.io.PrintWriter;
import java.util.ArrayDeque;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Scanner;

class Main {
	public static void main(String[] args) {
		new Main().run();
	}

	void run() {
		Scanner sc = new Scanner(System.in);
		int N = sc.nextInt();
		long K = sc.nextLong();
		int[] A = new int[N];
		int[][] B = new int[N][2];
		for (int i = 0; i < N; ++i) {
			A[i] = sc.nextInt();
			B[i] = new int[] { A[i], i };
		}

		Arrays.sort(B, new Comparator<int[]>() {
			@Override
			public int compare(int[] o1, int[] o2) {
				if (o1[0] != o2[0])
					return Integer.compare(o1[0], o2[0]);
				else
					return Integer.compare(o1[1], o2[1]);
			}
		});

		long[][] sum = new long[N][60];
		int[][] dst = new int[N][60];
		for (int i = 0; i < sum.length; ++i)
			for (int j = 0; j < sum[i].length; ++j)
				sum[i][j] = -1;
		for (int i = 0; i < N; ++i) {
			int j = i;
			while (j + 1 < N && B[j][0] == B[j + 1][0]) {
				dst[B[j][1]][0] = (B[j + 1][1] + 1) % N;
				sum[B[j][1]][0] = B[j + 1][1] - B[j][1] + 1;
				++j;
			}
			sum[B[j][1]][0] = N + B[i][1] - B[j][1] + 1;
			dst[B[j][1]][0] = (B[i][1] + 1) % N;
			i = j;
		}
		for (int i = 0; i + 1 < sum[0].length; ++i) {
			for (int j = 0; j < N; ++j) {
				sum[j][i + 1] = Math.min(sum[j][i] + sum[dst[j][i]][i], Long.MAX_VALUE / 3);
				dst[j][i + 1] = dst[dst[j][i]][i];
			}
		}

		long res = K * N;
		int pos = 0;
		while (res > 0) {
			int p = 59;
			while (p >= 0 && sum[pos][p] > res) {
				--p;
			}
			if (p == -1)
				break;
			res -= sum[pos][p];
			pos = dst[pos][p];
		}

		ArrayDeque<Integer> dq = new ArrayDeque<>();
		while (res > 0) {
			if (res >= sum[pos][0]) {
				res -= sum[pos][0];
				pos += sum[pos][0];
			} else {
				dq.addLast(A[pos]);
				++pos;
				--res;
			}
			pos %= N;
		}
		PrintWriter pw = new PrintWriter(System.out);
		while (!dq.isEmpty()) {
			pw.print(dq.pollFirst() + (dq.isEmpty() ? "\n" : " "));
		}
		pw.close();
	}

	void tr(Object... objects) {
		System.out.println(Arrays.deepToString(objects));
	}
}