#include <bits/stdc++.h>

using namespace std;


using lld = int64_t;

const int inf = 1e9;

class KM {
private:
    static constexpr lld INF = 1LL << 60;
    vector<lld> hl, hr, slk;
    vector<int> fl, fr, pre, qu;
    vector<vector<lld>> w;
    vector<bool> vl, vr;
    int n, ql, qr;
    bool check(int x) {
        if (vl[x] = true, fl[x] != -1)
            return vr[qu[qr++] = fl[x]] = true;
        while (x != -1)
            swap(x, fr[fl[x] = pre[x]]);
        return false;
    }
    void bfs(int s) {
        fill(slk.begin(), slk.end(), INF);
        fill(vl.begin(), vl.end(), false);
        fill(vr.begin(), vr.end(), false);
        ql = qr = 0;
        vr[qu[qr++] = s] = true;
        while (true) {
            lld d;
            while (ql < qr) {
                for (int x = 0, y = qu[ql++]; x < n; ++x) {
                    if (!vl[x] and slk[x] >= (d = hl[x] + hr[y] - w[x][y])) {
                        if (pre[x] = y, d) slk[x] = d;
                        else if (!check(x)) return;
                    }
                }
            }
            d = INF;
            for (int x = 0; x < n; ++x)
                if (!vl[x] and d > slk[x]) d = slk[x];
            for (int x = 0; x < n; ++x) {
                if (vl[x]) hl[x] += d;
                else slk[x] -= d;
                if (vr[x]) hr[x] -= d;
            }
            for (int x = 0; x < n; ++x)
                if (!vl[x] and !slk[x] and !check(x))
                    return;
        }
    }
public:
    void init(int n_) {
        qu.resize(n = n_);
        fl.assign(n, -1);
        fr.assign(n, -1);
        hr.assign(n, 0);
        hl.resize(n);
        w.assign(n, vector<lld>(n));
        slk.resize(n);
        pre.resize(n);
        vl.resize(n);
        vr.resize(n);
    }
    void set_edge(int u, int v, lld x) {
        w[u][v] = x;
    }
    lld solve() {
        for (int i = 0; i < n; ++i)
            hl[i] = *max_element(w[i].begin(), w[i].end());
        for (int i = 0; i < n; ++i) bfs(i);
        lld res = 0;
        for (int i = 0; i < n; ++i)
            res += w[i][fl[i]];
        return res;
    }
} km;

int main() {
    cin.tie(nullptr) -> sync_with_stdio(false);
    int N, M;
    cin >> N >> M;
    vector<int> a(N), b(N);
    for (int i = 0; i < N; i++) {
        cin >> a[i];
        --a[i];
    }
    for (int i = 0; i < N; i++) {
        cin >> b[i];
        --b[i];
    }

    vector<vector<int>> W(M, vector<int>(M));
    for (int i = 0; i < N; i++) {
        W[a[i]][b[i]] += 1;
    }

    km.init(M);
    for (int x = 0; x < M; x++) {
        for (int y = 0; y < M; y++) {
            km.set_edge(x, y, W[x][y]);
        }
    }

    int best = km.solve();

    vector<int> vis(M);
    vector<int> perm(M);

    for (int i = 0; i < N; i++) {
        int x = a[i];

        if (vis[x]) {
            continue;
        }
        vis[x] = true;

        const auto calc = [&](int pref) {
            auto tW = W;
            for (int y = 0; y < M; y++) {
                if (y > pref)
                    tW[x][y] = -inf;
            }
            km.init(M);
            for (int z = 0; z < M; z++) {
                for (int y = 0; y < M; y++) {
                    km.set_edge(z, y, tW[z][y]);
                }
            }
            return km.solve();
        };

        int pos = -1;
        for (int s = 1<<6; s; s >>= 1) {
            if (calc(pos + s) != best) {
                pos += s;
            }
        }

        ++pos;

        // cerr << "x = " << x << endl;
        // cerr << "pos = " << pos << endl;

        perm[x] = pos;

        for (int y = 0; y < M; y++)
            if (y != pos)
                W[x][y] = -inf;
        for (int z = 0; z < M; z++)
            if (z != x)
                W[z][pos] = -inf;
    }

    // cerr << N - best << '\n';
    for (int i = 0; i < N; i++)
        cout << perm[a[i]] + 1 << (i+1==N ? '\n' : ' ');


    return 0;
}