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
//make sure to make new file!
import java.io.*;
import java.util.*;

public class Main{
   
   public static void main(String[] args)throws IOException{
      BufferedReader f = new BufferedReader(new InputStreamReader(System.in));
      PrintWriter out = new PrintWriter(System.out);
      
      StringTokenizer st = new StringTokenizer(f.readLine());
      
      int n = Integer.parseInt(st.nextToken());
      long m = Long.parseLong(st.nextToken());
      
      int[] array = new int[n+1];
      st = new StringTokenizer(f.readLine());
      
      int[] next = new int[n+1];
      HashMap<Integer,Integer> last = new HashMap<Integer,Integer>();
      
      //stores first instance of each number
      HashMap<Integer,Integer> indexof = new HashMap<Integer,Integer>();
      
      for(int k = 0; k < n; k++){
         array[k] = Integer.parseInt(st.nextToken());
         next[k] = -1;
         if(last.containsKey(array[k])){
            next[last.get(array[k])] = k;
         }
         last.put(array[k],k);
         
         if(!indexof.containsKey(array[k])){
            indexof.put(array[k],k);
         }
         
      }
      
      next[n] = -1;
      array[n] = -1;
      
      
      ArrayList<Integer> before = new ArrayList<Integer>();
      
      before.add(-1);
      
      int i = 0;
      while(next[i] != -1){
         i = next[i]+1;
      }
      if(i >= n){
         out.close();
         System.exit(0);
      }
      before.add(array[i]);
      
      int start = indexof.get(array[i])+1;
      while(start < n){
         
         i = start;
         while(next[i] != -1){
            i = next[i]+1;
         }
         if(array[i] == -1) break;
         before.add(array[i]);
         start = indexof.get(array[i])+1;
      }

      
      
      int index = (int)(m % (long)before.size())-1;
      if(index == -1){
         index = before.size()-1;
      }
      
      ArrayList<Integer> answer = new ArrayList<Integer>();
      start = before.get(index);
      if(start != -1) index = indexof.get(start)+1;
      else index = 0;
      while(index < n){
         
         if(next[index]!=-1)index=next[index]+1; 
         else{
            answer.add(array[index]);
            index++;
         }
      }
      
      for(int a : answer){
         out.print(a + " ");
      }
      
      
      
      
      out.close();
   }
   
      
}