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
from collections import defaultdict
from bisect import bisect

def solve(K,A):
    N = len(A)
    indices = defaultdict(list)
    for i,a in enumerate(A):
        indices[a].append(i)

    memo = [False]*N
    memo[0] = True
    trace = [0]
    cnt = [0]
    while True:
        i = trace[-1]
        c = cnt[-1]
        l = indices[A[i]]
        j = (l[bisect(l,i)%len(l)]+1)%N
        if j == 0 and i+1==N:
            c += 2
        elif j <= i+1:
            c += 1
        trace.append(j)
        cnt.append(c)
        if memo[j]:
            break
        else:
            memo[j] = True

    i = trace.index(trace[-1])

    period = cnt[-1] - cnt[i]
    if K > cnt[i]:
        K = (K-cnt[i])%period + cnt[i]
    if K == 0:
        return tuple()
    head = trace[bisect(cnt, K-1)-1]
    # print(cnt)
    # print(trace)
    # print(period)
    # print(K)
    # print(head)
    ans = []
    cur = head
    while cur < N:
        l = indices[A[cur]]
        j = bisect(l, cur)
        if j == len(l):
            ans.append(cur)
            cur += 1
        else:
            cur = l[j]+1
    return tuple(A[i] for i in ans)

def naive(K,A):
    s = {}
    l = []
    for k in range(K):
        for a in A:
            try:
                i = l.index(a)
                l = l[:i]
            except ValueError:
                l.append(a)
    return tuple(l)

# from random import randrange

# for n in range(100):
#     K = randrange(1,4)
#     A = [randrange(10) for _ in range(10)]
#     s1 = solve(K,A)
#     s2 = naive(K,A)
#     if s1 != s2:
#         print(n)
#         print(K)
#         print(A)
#         print(s1)
#         print(s2)
#         exit()
# solve(2,[1,1,1])

N,K = map(int,input().split())
A = list(map(int,input().split()))
print(*solve(K,A))