//{{{
#include<algorithm>
#include<cmath>
#include<deque>
#include<fstream>
#include<iomanip>
#include<iostream>
#include<map>
#include<numeric>
#include<queue>
#include<random>
#include<set>
#include<sstream>
#include<sys/time.h>
#include<unordered_map>
#include<unordered_set>
#include<vector>
using ll = long long;
enum : int { M = (int)1e9 + 7 };
enum : ll { MLL = (ll)1e18L + 9 };
using namespace std;
#ifdef LOCAL
#include"rprint2.hpp"
#else
#define FUNC(name) template <ostream& out = cout, class... T> void name(T&&...){ }
FUNC(printde) FUNC(printdbe) FUNC(printdwe) FUNC(printdu);
#endif
template <template <class T, class = std::allocator<T>> class V, class E>
istream& operator >> (istream& in, V<E>& v){ for(auto& e : v){ in >> e; } return in; }
//}}}

int main(){
    cin.tie(0); ios::sync_with_stdio(false);
    ll n, k;
    cin >> n >> k;
    vector<int> as(n); cin >> as;

    // {
    //     unordered_map<int, int> mp;
    //     deque<int> nums;
    //     for(ll i = 0; i < k; i++){
    //         printde(i);
    //         for(int j = 0; j < n; j++){
    //             if(mp.count(as[j]) && (int)nums.size() > mp[as[j]] && nums[mp[as[j]]] == as[j]){
    //                 nums.resize(mp[as[j]]);
    //                 mp.erase(as[j]);
    //             }else{
    //                 mp[as[j]] = nums.size();
    //                 nums.push_back(as[j]);
    //             }
    //             // printde(as[j], nums,  mp);
    //         }
    //         printde(nums);
    //         // printde(mp);
    //         if(nums.empty()){
    //             printde(i + 1);
    //             break;
    //         }
    //     }
    // }

    deque<int> nums;
    auto as2 = as;
    unordered_map<int, int> mp;
    for(auto& a : as){
        mp[a]++;
    }
    unordered_set<int> us;
    for(auto& p : mp){
        if(p.second == 1){
            us.insert(p.first);
        }
    }

    vector<int> prevPos(2e5 + 1, -1);
    vector<int> prevIdx(n, -1);
    for(int i = 0; i < n; i++){
        prevIdx[i] = prevPos[as[i]];
        prevPos[as[i]] = i;
    }
    for(int i = 0; i < n; i++){
        prevIdx[i] = prevPos[as[i]];
        prevPos[as[i]] = i;
    }
    printde(prevIdx);
    vector<int> nextPos(2e5 + 1, -1);
    vector<int> nextIdx(n, -1);
    for(int i = n - 1; i >= 0; i--){
        nextIdx[i] = nextPos[as[i]];
        nextPos[as[i]] = i;
    }
    for(int i = n - 1; i >= 0; i--){
        nextIdx[i] = nextPos[as[i]];
        nextPos[as[i]] = i;
    }
    printde(nextIdx);

    int idx = n - 1;
    int cnt = 1; // + us.count(as[0]);
    while(1){
        int next = prevIdx[idx];
        cnt += us.count(as[idx]);
        if(next == 0){
            break;
        }
        if(next > idx){
            cnt++;
        }
        idx = next - 1;
    }
    k %= cnt;
    printde(cnt, k);

    if(k == 0){
        return 0;
    }
    int idx2 = 0;
    idx = 0;
    while(1){
        printde(idx);
        int next = nextIdx[idx];
        if(next < idx){
            k--;
        }
        k -= us.count(as[idx]);
        if(k == 0){
            idx2 = idx;
            break;
        }
        // if(next == n - 1){
        //     break;
        // }
        idx = next + 1;
    }

    printde(idx2);
    printde(us);
    int maxi = *max_element(as.begin(), as.end());
    {
        vector<int> mp;
        // for(ll i = 0; i < k; i++){
            // printde(i);
            if(nums.size() && us.count(nums[0])){
                nums.pop_front();
            }else{
                // unordered_map<int, int> mp;
                mp.assign(maxi + 1, -1);
                for(size_t i = 0; i < nums.size(); i++){
                    auto num = nums[i];
                    mp[num] = i;
                }
                for(int j = idx2; j < n; j++){
                    if(mp[as[j]] != -1 && (int)nums.size() > mp[as[j]] && nums[mp[as[j]]] == as[j]){
                        nums.resize(mp[as[j]]);
                        mp[as[j]] = -1;
                    }else{
                        mp[as[j]] = nums.size();
                        nums.push_back(as[j]);
                    }
                    // printde(as[j], nums,  mp);
                }
            }
            printde(nums);
            // printde(mp);
            // if(nums.empty()){
            //     printde(i + 1);
            //     // break;
            //     k = k % (i + 1) + (i + 1);
            // }
        // }
    }
    for(auto n : nums){
        cout << n << ' ';
    }

    // deque<int> nums;
    // auto as2 = as;
    // unordered_map<int, int> mp;
    // for(auto& a : as){
    //     mp[a]++;
    // }
    // unordered_set<int> us;
    // for(auto& p : mp){
    //     if(p.second == 1){
    //         us.insert(p.first);
    //     }
    // }
    // // sort(as2.begin(), as2.end());
    // // as2.resize(unique(as2.begin(), as2.end()) - as2.begin());
    // // poss.resize(unique(as2.begin(), as2.end()) - as2.begin());
    // // unordered_set<int> us(as2.begin(), as2.end());
    // printde(us);
    // for(ll i = 0; i < k; i++){
    //     printde(i);
    //     if(nums.size() && us.count(nums[0])){
    //         nums.pop_front();
    //     }else{
    //         unordered_map<int, int> mp;
    //         for(size_t i = 0; i < nums.size(); i++){
    //             auto num = nums[i];
    //             mp[num] = i;
    //         }
    //         for(int j = 0; j < n; j++){
    //             if(mp.count(as[j]) && (int)nums.size() > mp[as[j]] && nums[mp[as[j]]] == as[j]){
    //                 nums.resize(mp[as[j]]);
    //                 mp.erase(as[j]);
    //             }else{
    //                 mp[as[j]] = nums.size();
    //                 nums.push_back(as[j]);
    //             }
    //             // printde(as[j], nums,  mp);
    //         }
    //     }
    //     printde(nums);
    //     // printde(mp);
    //     if(nums.empty()){
    //         printde(i + 1);
    //         // break;
    //         k = k % (i + 1) + (i + 1);
    //     }
    // }
    // for(auto& n : nums){
    //     cout << n << ' ';
    // }

    // sort(as2.begin(), as2.end());
    // as2.resize(unique(as2.begin(), as2.end()) - as2.begin());
    // poss.resize(unique(as2.begin(), as2.end()) - as2.begin());
    // unordered_set<int> us(as2.begin(), as2.end());
    // printde(us);
    // int maxi = *max_element(as.begin(), as.end());
    // {
    //     vector<int> mp;
    //     for(ll i = 0; i < k; i++){
    //         printde(i);
    //         if(nums.size() && us.count(nums[0])){
    //             nums.pop_front();
    //         }else{
    //             // unordered_map<int, int> mp;
    //             mp.assign(maxi + 1, -1);
    //             for(size_t i = 0; i < nums.size(); i++){
    //                 auto num = nums[i];
    //                 mp[num] = i;
    //             }
    //             for(int j = 0; j < n; j++){
    //                 if(mp[as[j]] != -1 && (int)nums.size() > mp[as[j]] && nums[mp[as[j]]] == as[j]){
    //                     nums.resize(mp[as[j]]);
    //                     mp[as[j]] = -1;
    //                 }else{
    //                     mp[as[j]] = nums.size();
    //                     nums.push_back(as[j]);
    //                 }
    //                 // printde(as[j], nums,  mp);
    //             }
    //         }
    //         printde(nums);
    //         // printde(mp);
    //         if(nums.empty()){
    //             printde(i + 1);
    //             // break;
    //             k = k % (i + 1) + (i + 1);
    //         }
    //     }
    // }
    // for(auto n : nums){
    //     cout << n << ' ';
    // }
}


Measured memory_bytes: 23548