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 sys
stdin = sys.stdin

sys.setrecursionlimit(10 ** 7)

def li(): return map(int, stdin.readline().split())
def li_(): return map(lambda x: int(x) - 1, stdin.readline().split())
def lf(): return map(float, stdin.readline().split())
def ls(): return stdin.readline().split()
def ns(): return stdin.readline().rstrip()
def lc(): return list(ns())
def ni(): return int(stdin.readline())
def nf(): return float(stdin.readline())

from collections import defaultdict
from bisect import bisect_left

n, k = li()
a = list(li())

a = a + a

# ジャンプ先
jump = defaultdict(lambda: -1)
buf = defaultdict(lambda: -1)
for i, ai in enumerate(a):
    if buf[ai] != -1:
        jump[buf[ai]] = i - buf[ai]

    buf[ai] = i

# 周期を求める
checkpoint = [0]
cur = 0

while cur == 0 or cur % n > 0:
    cur += jump[cur % n]
    cur += 1
    checkpoint.append(cur)

cycle = cur // n
mod = k % cycle

# あまり処理
if mod == 0:
    print()

else:
    last_idx = n * mod

    # シミュレーション
    start_idx = checkpoint[bisect_left(checkpoint, last_idx) - 1]
    s = []

    idx = start_idx
    while idx < last_idx:
        if idx + jump[idx % n] < last_idx:
            idx += jump[idx % n] + 1
        else:
            s.append(a[idx % n])
            idx += 1

    print(*s)
