p02964 AtCoder Grand Contest 036 - Do Not Duplicate
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
```python
from bisect import bisect_right
from collections import defaultdict

N, K = map(int, input().split())
As = list(map(int, input().split()))

indices_of_elem = defaultdict(list)
for i, A in enumerate(As):
    indices_of_elem[A].append(i)

empty_index = [0]
while True:
    cur_index = empty_index[-1]
    look_for_elem = As[cur_index%N]
    index_of_indices = bisect_right(indices_of_elem[look_for_elem], cur_index%N)
    if len(indices_of_elem[look_for_elem]) ==  index_of_indices:
        pair_end_index = (cur_index // N) * N + indices_of_elem[look_for_elem][0] + N
    else:
        pair_end_index = (cur_index // N) * N + indices_of_elem[look_for_elem][index_of_indices]

    new_index = pair_end_index + 1
    empty_index.append(new_index)
    if new_index % N == 0:
        break
loop = new_index // N

#print(loop, empty_index)

K %= loop

if K == 0:
    exit()
else:
    start = empty_index[bisect_right(empty_index, K * N) - 1] % N
    tmp_ans = As[start:]

#print(tmp_ans)

index_for_tmp_ans = dict()
split = []
for i, elem in enumerate(tmp_ans):
    if elem in index_for_tmp_ans:
        split.append((index_for_tmp_ans[elem], i))
        while True:
            k, v = index_for_tmp_ans.popitem()
            if k == elem:
                break
    else:
        index_for_tmp_ans[elem] = i

for start, end in split:
    tmp_ans[start:end+1] = [-1] * (end - start + 1)

for ans in tmp_ans:
    if ans != -1:
        print(ans, end = ' ')
        

```