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 java.util.*;
import java.io.*;

public class Main {
    static void answer(LinkedList<Long> list){
        int i=0;
        for(long e:list){
            System.out.print(e);
            i++;
            if(i<list.size()) System.out.print(" ");
            else System.out.println();
        }
        System.exit(0);
    }
    static LinkedList<Long> simulate(LinkedList<Long> initial, long[] A, int startIndex){
        Set<Long> set = new HashSet<>();
        for(long e:initial) set.add(e);
        for(int n=startIndex; n<A.length; n++){
            if(!set.contains(A[n])){
                initial.addLast(A[n]);
                set.add(A[n]);
            }
            else{
                while(initial.getLast()!=A[n]){
                    set.remove(initial.getLast());
                    initial.removeLast();
                }
                set.remove(A[n]);
                initial.removeLast();
            }
        }
        return initial;
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int N = sc.nextInt();
        long K = sc.nextLong();
        long[] A = new long[N];
        for(int n=0; n<N; n++) A[n] = sc.nextLong();

        Map<Long, Long> jump = new HashMap<>();
        {
            Map<Long, Long> lastAppear = new HashMap<>();
            for(int n=0; n<N*2; n++){
                if(lastAppear.containsKey(A[n%N])){
                    jump.putIfAbsent(lastAppear.get(A[n%N]), (long)n);
                }
                lastAppear.put(A[n%N], (long)(n%N));
            }
        }

        for(long a=N-1; a>=0; a--){
            if(jump.containsKey(a) && jump.get(a)<N-1){
                jump.put(a, jump.get(jump.get(a)+1));
            }
        }

        long current = 0;
        Map<Long, Long> visited = new HashMap<>();
        visited.put(0L,0L);
        while(current < N*K){
            long curIndex = current%N;
            if(current >= N * (K-1)){
                answer(simulate(new LinkedList<>(), A, (int)curIndex));
            }
            long next = current - curIndex + jump.get(curIndex) + 1;
            if(next >= N*K) {
                answer(simulate(new LinkedList<>(), A, (int)curIndex));
                break;
            }
            if(visited.containsKey(next%N)){
                long period = next - visited.get(next%N);
                long circ = (N*K-next)/period;
                next += period * circ;
            }
            current = next;
        }
    }
}