output_description: Print the elements of s after Snuke finished the operations, in order from
  beginning to end, with spaces in between.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      N K
      A_0 A_1 \cdots A_{N-1}
attempt: import math
  
  # input
  #
  # n = 5
  # k = 10
  # a = [1, 2, 3, 2, 3]
  
  n, k = map(int, input().split())
  a = [int(ai) for ai in input().split()]
  
  # make jumpto
  #
  # 0 -> 6 (5)
  # 1 -> 4 (2)
  # 2 -> 5 (2)
  # 3 -> 7 (3)
  # 4 -> 8 (3)
  
  jumpto = [[-1] * n]
  la = -1
  li = -1
  for ca, ci in sorted(zip(a, range(n))):
      if ca == la:
          jumpto[0][ci] = jumpto[0][li] + li - ci
          jumpto[0][li] = ci - li
      else:
          jumpto[0][ci] = n
      la = ca
      li = ci
  
  # doubling jumpto
  #
  # 0 -> 6 ->  9 (8)
  # 1 -> 4 ->  8 (6)
  # 2 -> 5 -> 11 (8)
  # 3 -> 7 -> 10 (6)
  # 4 -> 8 -> 12 (7)
  #
  # 0 -> 6 ->  9 -> 13 -> 17  (16)
  # 1 -> 4 ->  8 -> 12 -> 15  (13)
  # 2 -> 5 -> 11 -> 14 -> 18  (15)
  # 3 -> 7 -> 10 -> 16 -> 19  (15)
  # 4 -> 8 -> 12 -> 15 -> 21  (16)
  
  levels = int(math.log(k, 2))
  for l in range(1, levels + 1):
      jumpto.append([-1] * n)
      for i in range(n):
          f = jumpto[l - 1][i]
          s = jumpto[l - 1][(i + f + 1) % n]
          jumpto[l][i] = f + 1 + s
  
  # step1
  s = 0
  while True:
      jumped = False
      for l in range(levels, -1, -1):
          if s + jumpto[l][s % n] < n * k:
              s += jumpto[l][s % n] + 1
              jumped = True
              break
      if not jumped:
          break
  
  # step2
  ret = []
  while s < n * k:
      if s + jumpto[0][s % n] < n * k:
          s = s + jumpto[0][s % n] + 1
      else:
          ret.append(str(a[s % n]))
          s += 1
  
  print(" ".join(ret))
  
problem_description: Statement
  
  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.
samples: [{"input": "3 2\n    1 2 3", "output": "2 3\n    \n\nIn this case, X=(1,2,3,1,2,3). We will perform the operations as follows:\n\n  * i=0: s does not contain 1, so we add 1 to the end of s, resulting in s=(1).\n  * i=1: s does not contain 2, so we add 2 to the end of s, resulting in s=(1,2).\n  * i=2: s does not contain 3, so we add 3 to the end of s, resulting in s=(1,2,3).\n  * i=3: s does contain 1, so we repeatedly delete the element at the end of s as long as s contains 1, which causes the following changes to s: (1,2,3)\u2192(1,2)\u2192(1)\u2192().\n  * i=4: s does not contain 2, so we add 2 to the end of s, resulting in s=(2).\n  * i=5: s does not contain 3, so we add 3 to the end of s, resulting in s=(2,3).\n\n* * *"}, {"input": "5 10\n    1 2 3 2 3", "output": "3\n    \n\n* * *"}, {"input": "6 1000000000000\n    1 1 2 2 3 3", "output": "s may be empty in the end.\n\n* * *"}, {"input": "11 97\n    3 1 4 1 5 9 2 6 5 3 5", "output": "9 2 6"}]