#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <fstream>
#include <iostream>
#include <sstream>
#include <iomanip>
#include <algorithm>
#include <bitset>
#include <array>
#include <vector>
#include <queue>
#include <set>
#include <cmath> // 変数名にy1が使えなくなるかも…。
#include <map>
#include <unordered_map>
#include <unordered_set>
#include <limits>
#include <functional>
#include <string>

typedef __int128_t int128_t;
std::istream &operator>>(std::istream& input, int128_t& value) { // int128_tの入力。入力が64bitに収まる前提。
    long long tmp; input >> tmp; value = tmp;
    return input;
}
std::ostream &operator<<(std::ostream& output, const int128_t value) { // int128_tの出力。出力が64bitに収まる前提。
    output << (long long)value;
    return output;
}

// binary search result
struct BSR {
    bool found; // 条件を満たす範囲が見つかったか。falseの場合、begin,endは意味を持たない。
    int128_t begin; // [begin, end]で条件が成り立つ。
    int128_t end;
    BSR(bool found_in, int128_t begin_in, int128_t end_in) { found = found_in; begin = begin_in; end = end_in; }
    //BSR(bool found_in, int128_t begin_in, int128_t end_in) : found(found_in), begin(begin_in), end(end_in) {}
};

//template<class Fn> BSR binary_search(int128_t L, int128_t R, Fn func) {
BSR binary_search(int128_t L, int128_t R, std::function<bool(int128_t)> func) {
    const bool res_L = func(L);
    const bool res_R = func(R);
    if (res_L && res_R) {
        return BSR(true, L, R);
    } else if (!res_L && !res_R) {
        return BSR(false, 0, 0);
    } else {
        int128_t lb = L;
        int128_t ub = R;
        while (lb + 1 < ub) {
            int128_t mid = (lb + ub) / 2;
            if (res_L == func(mid)) {
                lb = mid;
            } else {
                ub = mid;
            }
        }
        return res_L ? BSR(true, L, lb) : BSR(true, ub, R);
    }
}

// 写像mpをxにnum回作用させた場合の結果を計算。
// mpの定義域は10^5程度を想定していて、値域が定義域に含まれていることが条件。
// この場合、numが非常に大きい値であっても、いずれループするのでnumをループのサイズで割った余りに置き換えることができて、計算時間がnumに依存しなくなる。
// mpがmapやunordered_mapのときに
// auto ret = map_loop(mp, x, num);
// の形式で呼び出すことができる。原因があまりよくわからないが、mpをconstにするとコンパイルできない。また、VSCodeでは呼び出したところに赤の波線が表示される。
// 戻り値は、firstが作用後の値で、secondがループのサイズ。
template<template <typename...> class Tm, typename T>
std::pair<T, int> map_loop(Tm<T, T>& mp, T x, int128_t num) {
    Tm<T, int> path; path[x] = 0;
    int loop_size = 0;
    int cnt = 1;
    while (num) {
        x = mp[x];
        num--;
        if (path.count(x)) {
            loop_size = cnt - path[x];
            num = num % loop_size;
        } else {
            path[x] = cnt;
        }
        cnt++;
    }
    return std::pair<T, int>({x, loop_size});
}

#define rep(i, begin, end) for(int64_t i = (begin); i <= (end); i++)
#define rev(i, begin, end) for(int64_t i = (begin); (end) <= i; i--)

void printvec(const std::vector<int>& vec) {
    for (int i = 0; i < vec.size(); i++) { std::cout << vec[i] << " "; } std::cout << std::endl;
}

const int MAX_N = 2e5 + 10;
int128_t N, K;
int A[MAX_N];

std::unordered_map<int, std::vector<int>> mp;

std::unordered_map<int, int> change;

int top_if[MAX_N];

int main(int argc, char **argv) {
    std::cin >> N >> K;

    rep (i, 0, N-1) {
        std::cin >> A[i];
        mp[A[i]].push_back(i);
    }

    top_if[N] = 0;
    rev (i, N-1, 0) {
        if (mp[A[i]].back() == i) {
            top_if[i] = A[i];
        } else {
            auto bsr = binary_search(0, mp[A[i]].size() - 1, [&](int j){
                return i < mp[A[i]][j];
            });
            assert(bsr.found);
            top_if[i] = top_if[mp[A[i]][bsr.begin] + 1];
        }
    }

    change[0] = top_if[0];
    for (auto p : mp) {
        change[p.first] = top_if[p.second[0]+1];
    }

    auto prev = map_loop(change, 0, K - 1);

    std::vector<int> ret;
    std::set<int> st;
    int start = 0;

    if (prev.first != 0) {
        start = mp[prev.first][0] + 1;
    }

    rep (i, start, N-1) {
        if (st.count(A[i])) {
            while (true) {
                if (ret.back() == A[i]) {
                    st.erase(ret.back());
                    ret.pop_back();
                    break;
                } else {
                    st.erase(ret.back());
                    ret.pop_back();
                }
            }
        } else {
            ret.push_back(A[i]);
            st.insert(A[i]);
        }
    }

    for (int i : ret) {
        std::cout << i << " ";
    }
    std::cout << std::endl;

    return 0;
}

Measured memory_bytes: 39112