Problem:
Score : 700 points

Problem Statement

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.

Sample Input 1

3 2
1 2 3

Sample Output 1

2 3

In this case, X=(1,2,3,1,2,3).
We will perform the operations as follows:

i=0: s does not contain 1, so we add 1 to the end of s, resulting in s=(1).

i=1: s does not contain 2, so we add 2 to the end of s, resulting in s=(1,2).

i=2: s does not contain 3, so we add 3 to the end of s, resulting in s=(1,2,3).

i=3: s does contain 1, so we repeatedly delete the element at the end of s as long as s contains 1, which causes the following changes to s: (1,2,3)→(1,2)→(1)→().

i=4: s does not contain 2, so we add 2 to the end of s, resulting in s=(2).

i=5: s does not contain 3, so we add 3 to the end of s, resulting in s=(2,3).

Sample Input 2

5 10
1 2 3 2 3

Sample Output 2

3

Sample Input 3

6 1000000000000
1 1 2 2 3 3

Sample Output 3

s may be empty in the end.

Sample Input 4

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

Sample Output 4

9 2 6

Solution in Java8 (OpenJDK 1.8.0) (judge verdict: Wrong Answer)

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] = sum[j][i] + sum[dst[j][i]][i];
				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;
		}
		while (!dq.isEmpty()) {
			System.out.print(dq.poll() + (dq.isEmpty() ? "\n" : " "));
		}
	}

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