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 sys
  
  sys.setrecursionlimit(2147483647)
  INF = float("inf")
  MOD = 10**9 + 7
  input = lambda: sys.stdin.readline().rstrip()
  
  
  def resolve():
      n, k = map(int, input().split())
      A = list(map(int, input().split()))
      idx = [[] for _ in range(max(A) + 1)]
      for i, a in enumerate(A):
          idx[a].append(i)
      perm = [None] * n
      for I in idx:
          s = len(I)
          for i in range(s):
              if i != s - 1:
                  perm[I[i]] = (I[i + 1] + 1) % n
              else:
                  perm[I[i]] = (I[0] + 1) % n
  
      # perm の 先頭要素をサイクル分解する
      cycle = [0]
      v = perm[0]
      while v:
          cycle.append(v)
          v = perm[v]
  
      # 元に戻るまで何周したか -> まずは k をこれで割る
      cycle.append(0)
      cnt = 0
      for i in range(len(cycle) - 1):
          if cycle[i + 1] < cycle[i] or cycle[i] + 1 == cycle[i + 1]:
              cnt += 1
      k %= cnt
  
      # k が 0 になるまで消費する
      for i in range(len(cycle) - 1):
          s = cycle[i + 1] < cycle[i] or cycle[i] + 1 == cycle[i + 1]
          if k - s <= 0:
              break
          else:
              k -= s
  
      # cycle[i] 以降の数列について、実際に構成すればよい
      ans = []
      i = cycle[i]
      while i != 0 and i != n:
          if i == n - 1:
              ans.append(A[i])
              i += 1
          elif perm[i] == 0:
              i = n
          elif perm[i] == i + 1 or perm[i] < i:
              ans.append(A[i])
              i += 1
          else:
              i = perm[i]
      print(*ans)
  
  
  resolve()
  
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"}]