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
N, K = map(int, input().split())
A = list(map(int, input().split()))

# first : 数列Aのi番目以降の要素で操作をしたときに残っている最初の数字
#   first[idx] > 0  => idxからスタート
#   first[idx] == 0 => 空の数列が残る
#   first[idx] < 0  => follow_idx[idx]からスタート(後々スタートの数だけ取り出したいため区別して負の数で保持)
# follow_idx : 数列Aのi番目以降の要素で操作をしたときに残っている次の数のindex
first = [0] * (N+1)
follow_idx = [-1] * (N+1)
# d : ある数字が出現したindexを記憶
d = {}
for i, a in enumerate(A[::-1]):
  j = N - 1 - i
  # 自分よりも後に自分と同じ数字が出現する場合、その位置まで消えて、その次からスタートしたときと同じものが残る
  if a in d:
    idx = d[a][-1] + 1 # j以降にaと同じ数字が出現するindexの中で最も近いもの次のindex
    d[a].append(j)
    if first[idx] < 0: # 負の数 => idx番目の数からスタートしない
      first[j] = first[idx] # 自身から始まらないため、ここも負の数のまま保持
      follow_idx[j] = follow_idx[idx] # 本当に始まるindexを記録
    else: # 正の数 => idx番目からスタートする
      first[j] = -first[idx] # 自身から始まらないため、負の数で保持
      follow_idx[j] = idx # 本当はidxから始まる
  
  # 自分よりも後に自分と同じ数字が出現しない場合、先頭に自身を追加して、一つ後ろからスタートしたときと同じものが残る
  else:
    first[j] = a # 自身からスタート
    d[a] = [j]
    follow_idx[j] = j + 1 # 自身の次は一つ後ろにつながる


# indices : 先頭の数字が元の数列でどのindexだったかを記録
indices = [-1] # ダミー
s0 = first[0] # 数列を1つだけ並べて操作を行ったときに残る先頭の数字
if s0 >= 0: 
  indices.append(0) # 0以上の場合、自身から始まる
else:
  s0 = -s0 # 負の場合、正の値に戻す
  indices.append(follow_idx[0]) # 自身から始まるわけではないので、本当に始まるindexを追加

if s0 == 0: # 数列を1つ並べて操作を行った後の数列が空 => 何個並べても最終的に空になる
  print('')
  quit()

# first_a : 先頭の数字として出現したものを記録
#   key : 先頭の数字
#   value : 数列Aを何個並べて操作を行った場合か
first_a = {0:0, s0:1}
for k in range(2, K+1):
  idx = d[s0][-1] + 1 # 先頭の数字が最初に現れるとそこまで消えて、その次からスタートする
  s0 = first[idx] # 上で求めたスタート位置から始めたときに残る数列の先頭の数字
  if s0 >= 0: # 0以上ならその数字自身から始まる
    indices.append(idx) # ので、idxをそのまま記録
  else: # 負の数なら、本当はその位置から始まるわけではない
    s0 = -s0 # 一旦、正の値に戻しておく
    indices.append(follow_idx[idx]) # 本当のスタート位置を記録
  if s0 in first_a: # 既にその数からスタートしたことがある => ここから先は周期的に振る舞う
    break
  first_a[s0] = k # s0が先頭となるkを記録しておく

if len(indices) < K: # 周期を発見してシミュレーションが終了した場合、Kを更新
  # 1, 2, ..., first_a[s0], ..., k
  # ?, ?, ..., s0,          ..., s0
  #              <------------->
  #                 ここが周期
  K = first_a[s0] + (K - first_a[s0]) % (k - first_a[s0])

if K == 0: # 丁度からの数列になったときに終了している
  print('')
  quit()

ans = []
idx = indices[K] # ここからスタートしたときに残る数列と同じものが残る
while idx < N: # 最後尾になるまで後ろ側に辿っていく
  s = first[idx]
  if s > 0: # 正で保持されているなら、その数字を使うということなのでansに追加
    ans.append(s)
  idx = follow_idx[idx]

print(*ans)