#include <algorithm>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <deque>
#include <iostream>
#include <iterator>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

#define FOR(i,k,n) for(int(i)=(k);(i)<(n);++(i))
#define rep(i,n) FOR(i,0,n)
#define all(v) begin(v),end(v)
#define debug(x) //std::cerr<<#x<<": "<<x<<"\n"
#define debug2(x,y) //std::cerr<<#x<<": "<<x<<", "<<#y<<": "<<y<<"\n"
#define debug3(x,y,z) //std::cerr<<#x<<": "<<x<<", "<<#y<<": "<<y<<", "<<#z<<": "<<z<<"\n"

using ll=long long;
using vi=std::vector<int>;
using vvi=std::vector<vi>;
using vll=std::vector<ll>;
using vvll=std::vector<vll>;
template<typename T> using vvec=std::vector<std::vector<T>>;
template<typename T>
auto make_v(size_t sz){return std::vector<T>(sz);}
template<typename T,typename... Ts>
auto make_v(size_t sz,Ts...ts){return std::vector<decltype(make_v<T>(ts...))>(sz,make_v<T>(ts...));}
template<typename T>
void fill_v(T&var,const T&x){var=x;}
template<typename V,typename T>
void fill_v(V&v,const T&x){for(auto&& w:v){fill_v(w,x);}}

template<typename T> std::ostream& operator<<(std::ostream&s,const std::vector<T>&v){
  int sz=v.size();s<<"\n";rep(i,sz){s<<v[i];if(i<sz-1){s<<"\t";}}s<<"\n";return s;}
template<typename T> std::ostream& operator<<(std::ostream&s,const std::vector<std::vector<T>>&v){
  for(auto&& w:v){s<<w;}return s;}
template<typename T> std::ostream& operator<<(std::ostream&s,const std::deque<T>&v){
  int sz=v.size();s<<"\n";rep(i,sz){s<<v[i];if(i<sz-1){s<<"\t";}}s<<"\n";return s;}
template<typename T> std::ostream& operator<<(std::ostream&s,const std::deque<std::deque<T>>&v){
  for(auto&& w:v){s<<w;}return s;}
template<typename T> std::ostream& operator<<(std::ostream&s, const std::set<T>&v){
  s<<"\n";for(auto&& elm:v){s<<elm<<"\t";}s<<"\n";return s;}

inline void scan(int&a){scanf("%d",&a);}
inline void scan(ll&a){scanf("%lld",&a);}
inline void scan(char&a){scanf(" %c",&a);}
inline void scan(double&a){scanf("%lf",&a);}
inline void scan(std::string&s){char BUF[3000000];scanf(" %s",BUF);s=std::string(BUF);}
template<typename T>
inline void scan(std::vector<T>&v){for(auto&& sv:v){scan(sv);}}
template<typename First,typename...Args>
inline void scan(First&f,Args&...args){scan(f);scan(args...);}
inline void print(int a){printf("%d\n",a);}
inline void print(ll a){printf("%lld\n",a);}
inline void print(double a){printf("%.12f\n",a);}
inline void print(std::string s){std::cout<<s<<"\n";}

using namespace std;

struct Monoid {
  using T = int; // type or class of monoid
  static T operate(const T& left, const T& right) {
    if (left != -1) return left;
    else return right;
  }
  static constexpr T identity() { return T(-1); } // 単位元
};

struct M_act {
  using T = int;
  using OperatorMonoid = Monoid;
  static T act(const OperatorMonoid::T& m, const T& a) {
    if (m != -1) return m;
    else return a;
  }
};

template<class M_act>
class SegTree {
private:
  using T = typename M_act::T;
  using OM = typename M_act::OperatorMonoid;
  using M = typename OM::T;
  const int n, h;
  std::vector<T> uv; // underlying values
  std::vector<M> deferred_action;

  void propagate(const M& m, int i) {
    if (i < n) deferred_action[i] = OM::operate(m, deferred_action[i]); // if not leaves, unite actions
    else {
      i -= n;
      uv[i] = M_act::act(m, uv[i]); // if leaves, act immediately
    }
  }

  void propagate_from(int i) {
    if (deferred_action[i] == OM::identity()) { return; }
    propagate(deferred_action[i], i << 1);
    propagate(deferred_action[i], i << 1 | 1);
    deferred_action[i] = OM::identity();
  }

  void propagate_to_uv(int i) {
    i += n;
    for (int j = h; j > 0; --j) propagate_from(i >> j);
  }

  int lg(int n_) {
    n_ -= 1;
    int h_ = 0;
    while (n_ >> h_) ++h_;
    return h_;
  }

public:
  SegTree(int n_, const T& x) : n(n_), h(lg(n)), uv(n, x), deferred_action(n, OM::identity()) {}
  SegTree(const std::vector<T>& v) : n(v.size()), h(lg(n)), uv(v), deferred_action(n, OM::identity()) {}
  template<class Itr>
  SegTree(Itr first, Itr last) : n(std::distance(first, last)), h(lg(n)), uv(first, last), deferred_action(n, OM::identity()) {}

  void act(int l, int r, const M& m) {
    propagate_to_uv(l);
    propagate_to_uv(r-1);
    l += n, r += n;
    for ( ; l < r; l >>= 1, r >>= 1) {
      if (l & 1) propagate(m, l++);
      if (r & 1) propagate(m, r-1);
    }
  }

  void propagate_all() {
    for (int i = 1; i < n; ++i) propagate_from(i);
  }

  void set(int i, const T& x) {
    propagate_to_uv(i);
    uv[i] = x;
  }

  T get(int i) {
    T ret = uv[i];
    i += n;
    while (i >>= 1) ret = M_act::act(deferred_action[i], ret);
    return ret;
  }

  std::vector<T> get_v() {
    return uv;
  }
};

int main() {
  int n;
  ll k;
  scan(n, k);
  vi a(n);
  scan(a);
  int m = 200001;
  //m = 10;
  vvi indices(m);
  rep (i, n) {
    indices[a[i]].push_back(i);
  }
  debug(indices);

  vi remain(n+1, n);
  {
    vi wolfi;
    vi lefti;
    set<int> si;
    for (int i = n-1; i >= 0; --i) {
      if (si.find(a[i]) == end(si)) {
        wolfi.push_back(i);
        si.insert(a[i]);
      }
    }
    reverse(all(wolfi));
    debug(wolfi);
    for (int ind : wolfi) {
      int lb = lower_bound(all(indices[a[ind]]), ind) - begin(indices[a[ind]]);
      if (lb == 0) {
        lefti.push_back(0);
      } else {
        lefti.push_back(indices[a[ind]][lb - 1] + 1);
      }
    }
    debug(lefti);

    int sz = wolfi.size();
    auto segt = SegTree<M_act>(n, n);
    for (int i = sz-1; i >= 0; --i) {
      remain[wolfi[i]] = wolfi[i];
    }
    debug(remain);
    for (int i = n-1; i >= 0; --i) {
      if (remain[i] != n) {
        continue;
      }
      auto ub = upper_bound(all(indices[a[i]]), i);
      assert (ub != end(indices[a[i]]));
      remain[i] = remain[(*ub) + 1];
    }
    debug(remain);
  }

  vi first_index(m, -1);
  rep (i, n) {
    if (first_index[a[i]] == -1) {
      first_index[a[i]] = i;
    }
  }
  debug(first_index);

  int t;
  int prev = -1; // first index remaining
  vi prevs;
  for (int i = 1; true; ++i) {
    t = i;
    if (prev == -1) {
      prev = remain[0];
    } else {
      int fi = first_index[a[prev]];
      prev = remain[fi + 1];
    }
    prevs.push_back(prev);
    debug(prev);
    if (prev == n) {
      break;
    }
  }
  debug(t);

  int target = k % t;
  if (target == 0) {
    return 0;
  }

  int start_index;
  if (target == 1) {
    start_index = 0;
  } else {
    int prev = prevs[target - 2];
    start_index = first_index[a[prev]] + 1;
  }
  vi ans;
  for (int i = start_index; ; ) {
    if (remain[i] == n) {
      break;
    }
    ans.push_back(remain[i]);
    i = remain[i] + 1;
  }
  debug(ans);
  int sz = ans.size();
  rep (i, sz) {
    printf("%d%c", a[ans[i]], " \n"[i == sz-1]);
  }

  return 0;
}


Measured memory_bytes: 25460