Problem:
Score : 700 points

Problem 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.

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.

Sample Input 1

3 2
1 2 3

Sample Output 1

2 3

In this case, X=(1,2,3,1,2,3).
We will perform the operations as follows:

i=0: s does not contain 1, so we add 1 to the end of s, resulting in s=(1).

i=1: s does not contain 2, so we add 2 to the end of s, resulting in s=(1,2).

i=2: s does not contain 3, so we add 3 to the end of s, resulting in s=(1,2,3).

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)→(1,2)→(1)→().

i=4: s does not contain 2, so we add 2 to the end of s, resulting in s=(2).

i=5: s does not contain 3, so we add 3 to the end of s, resulting in s=(2,3).

Sample Input 2

5 10
1 2 3 2 3

Sample Output 2

3

Sample Input 3

6 1000000000000
1 1 2 2 3 3

Sample Output 3

s may be empty in the end.

Sample Input 4

11 97
3 1 4 1 5 9 2 6 5 3 5

Sample Output 4

9 2 6

Solution in C++14 (GCC 5.4.1) (judge verdict: Wrong Answer)

#include <bits/stdc++.h>
#include <boost/multiprecision/cpp_int.hpp>

using namespace std;
typedef long long int ll;

#define PI (acos(-1))
#define REP(i,n) for(int (i)=0;(i)<(n);(i)++)

#define dump(x)  cerr << #x << " = " << (x) << endl;
#define dumparr(x) cerr << #x ; for(auto elem: x){cerr << " " << elem;} cerr << endl;
#define dumppairs(x) cerr << #x ; for(auto elem: x){cerr << "(" << elem.first << " " << elem.second << ") ";} cerr << endl;
#define dumpline cerr << "**********************" << endl;
#define dumpwline(x) cerr << "******** " << #x << "=" << (x) << " ********" << endl;
#define debug(x) cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" << " " << __FILE__ << endl;
#define ARRAY_LENGTH(array) (sizeof(array) / sizeof(array[0]))


struct node{
    int idx;
    int next_idx;
    pair <int, int> get_next_same_num_idx(){
        int loop_added = 0;
        if (next_idx <= idx){
            loop_added = 1;
        }
        return {next_idx, loop_added};
    }
};


int main(void){
    ll n; cin >> n;
    ll k; cin >> k;
    vector <int> as;
    int a;
    REP(i, n){
        cin >> a;
        as.push_back(a);
    }
    dumparr(as)
    vector <vector <int>> matrix;
    REP(i, 2*1e5 + 1){
        vector <int> v; matrix.push_back(v);
    }
    REP(i, n){
        matrix[as[i]].push_back(i);
    }
    map <int, int> amap;
    vector <node> nodes;
    REP(i, n){
        int num = as[i];
        int cnt = matrix[num].size();
        int next_idx = matrix[num][(cnt + amap[num] + 1) % cnt];
        nodes.push_back({i, next_idx});
        amap[num]++;
    }

    int loop_cnt = 0;
    int idx = 0;
    while (1){
        pair<int, int> p = nodes[idx].get_next_same_num_idx();
        if (p.first == n-1){
            loop_cnt++;
            break;
        } else {
            loop_cnt += p.second;
            idx = p.first + 1;
        }
    }

    ll nk = n*k;
    nk = nk % (loop_cnt*n);

    loop_cnt = 0;
    idx = 0;
    node prev_node = nodes[n-1];
    while ((loop_cnt+1)*n + idx < nk){
        prev_node = nodes[idx];
        pair<int, int> p = nodes[idx].get_next_same_num_idx();
        if (p.first == n-1) {
            loop_cnt++;
            idx = 0;
        } else {
            loop_cnt += p.second;
            idx = p.first + 1;
        }
    }
    dump(loop_cnt*n + idx)
    dump(nk)
    vector <int> ss;
    for(ll i = loop_cnt*n + idx; i<nk; i++){
        int elem = as[i%n];
        auto found = find(ss.begin(), ss.end(), elem);
        if (found != ss.end()){
            ss.erase(found, ss.end());
        } else {
            ss.push_back(elem);
        }
    }
    REP(i, ss.size()){
        if (i < ss.size() - 1){
            cout << ss[i] << " ";
        } else {
            cout << ss[i] << endl;
        }
    }
    return 0;
}