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
def solve():
    N, K = [int(_) for _ in raw_input().split()]
    A = [(i, int(ele)) for i, ele in enumerate(raw_input().split())]
    sortA = sorted(A, key = lambda x: x[1])
    _next = [None] * N
    save = 0

    ## 1. Create _next list
    for i in range(1, N):
        if sortA[i][1] == sortA[save][1]:
            _next[sortA[i-1][0]] = sortA[i][0]
        else:
            _next[sortA[i-1][0]] = sortA[save][0]
            save = i
    _next[sortA[N-1][0]] = sortA[save][0]
    # print "_next: " + str(_next)

    ## 2. Create minimum times N0 to list X return empty list
    start = 0
    minCntToEmpty = 0
    while start != N:
        if _next[start] <= start:
            minCntToEmpty += 1
        start = _next[start] + 1
        # print "start: " +  str(start)
    minCntToEmpty +=1
    # print "minCntToEmpty: " + str(minCntToEmpty)

    ## 3. 4. CntDown = K%N0, run simulated start -> _next(start) + 1 until CntDown becomes 0
    cntDown = K % minCntToEmpty
    if cntDown == 0:
        print
        return
    # print "cntDown: " + str(cntDown)
    start = 0
    while cntDown > 1:
        if _next[start] <= start:
            cntDown -= 1
        start = _next[start] + 1
        # print "start: " +  str(start)

    ## 5. Run simulated to find final answer
    i = start
    # print "i: " + str(i)
    while i < N:
        if _next[i] <= i:
            print A[i][1],
            i += 1
        else:
            i = _next[i] + 1

if __name__ == '__main__':
    solve()
