#include <iostream>
#include <string>
#include <vector>
#include <unordered_map>
#include <algorithm>
#include <set>

using namespace std;


vector<int> tree;
int module;

void update(int i, int x) {
    i += module; tree[i] = x;
    while (i /= 2)
        tree[i] = min(tree[i * 2], tree[i * 2 + 1]);
}

int get_min(int l, int r) {
    int ans = 1000000000;
    int i = l + module;
    int j = r + module;
    while (i <= j) {
        if (i % 2 == 1) ans = min(ans, tree[i]);
        if (j % 2 == 0) ans = min(ans, tree[j]);
        i = (i + 1) / 2;
        j = (j - 1) / 2;
    }
    return ans;
}

void init(int n) {
    module = 2 * n + 100;
    tree.resize(2 * (n + module) + 100, 0);
}

vector<int> a;
vector<vector<int>> p;
vector<int> ans;

//set<pair<pair<int, int>, int>> sset;
set<pair<int, int>> sset;
int n, k;
/*
void doReplace() {
    ans.clear();
    ans.reserve(k);
    for (auto& item : sset) {
        ans.push_back(item.first.second);
    }
}
*/

int main() {
    ios_base::sync_with_stdio(false);
    cin >> n >> k;
    a.resize(n);
    p.resize(k);
    for (int i = 0; i < n; i++) {
        cin >> a[i];
        a[i]--;
        p[a[i]].push_back(i);
    }
    for (int i = 0; i < k; i++) {
        sset.insert({p[i].back(), i});
    }

    init(n);
    for (int i = 0; i < n; i++) {
        update(i, a[i]);
    }

    ans.reserve(k);

    int l = 0;
    for (int i = 0; i < k; i++) {
        int res = get_min(l, sset.begin()->first);
        int pos = *lower_bound(p[res].begin(), p[res].end(), l);
        ans.push_back(res);
        //cout << i << " " << l << " | " << res << " " << pos << endl;
        sset.erase(sset.find({p[res].back(), res}));
        for (auto item : p[res]) {
            update(item, 1000000000);
        }
        l = pos + 1;
    }

/*
    int cur_pos = 0;
    for (int i = 0; i < k; i++) {
        int j = 0;
        while (couldGet(cur_pos, j)) {

        }

    }



        sset.insert({{p[i][0], i}, 0});
    doReplace();

    while (true) {
        auto cur = *sset.begin();
        sset.erase(sset.begin());
        if (cur.second + 1 == (int)p[cur.first.second].size()) {
            break;
        }
        cur.second++;
        cur.first.first = p[cur.first.second][cur.second];
        sset.insert(cur);
        bool replace = false;
        if (sset.begin()->first.second != cur.first.second) {
            int pos = 0;
            for (auto& item : sset) {
                if (item.first.second != ans[pos]) {
                    replace = item.first.second < ans[pos];
                    break;
                }
                pos++;
            }
        }
        if (replace) {
            doReplace();
        }
    }
    * */

/*

    ans = a;
    int i = 0;
    while (i < n) {
        int last = 0;
        for (int j = 0; j < k; j++) {
            auto it = lower_bound(p[j].begin(), p[j].end(), i);
            if (it == p[j].end()) {
                last = -1;
                break;
            }
            last = max(last, *it);
        }
        if (last == -1) {
            break;
        }
        cout << i << " " << last - i + 1 << endl;
        bool replace = (last - i + 1) < (int)ans.size();
        if (last - i + 1 == (int)ans.size()) {
            for (int j = 0; j < last - i; j++) {
                if (a[i + j] != ans[j]) {
                    replace = a[i + j] < ans[j];
                    break;
                }
            }
        }
        if (replace) {
            ans = std::vector<int>(a.begin() + i, a.begin() + last + 1);
        }
        i++;
    }
*/
    for (auto item : ans) {
        cout << item + 1 << " ";
    }

    return 0;
}