#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
#ifdef APURBA
#include "DEBUG_TEMPLATE.h"
#else
#define HERE
#define debug(args...)
#endif
#define ALL(x) x.begin(),x.end()
const int M = 65;

struct Hungarian
{
    long long c[M][M], fx[M], fy[M], d[M];
    int l[M], r[M], arg[M], trace[M];
    queue<int> q;
    int start, finish, n;
    const long long inf = 1e18;
    Hungarian() {}
    Hungarian(int n1, int n2): n(max(n1, n2))
    {
        for (int i = 1; i <= n; ++i)
        {
            fy[i] = l[i] = r[i] = 0;
            for (int j = 1; j <= n; ++j) c[i][j] = inf;
        }
    }
    void add_edge(int u, int v, long long cost)
    {
        c[u][v] = min(c[u][v], cost);
    }
    inline long long getC(int u, int v)
    {
        return c[u][v] - fx[u] - fy[v];
    }
    void initBFS()
    {
        while (!q.empty()) q.pop();
        q.push(start);
        for (int i = 0; i <= n; ++i) trace[i] = 0;
        for (int v = 1; v <= n; ++v)
        {
            d[v] = getC(start, v);
            arg[v] = start;
        }
        finish = 0;
    }
    void findAugPath()
    {
        while (!q.empty())
        {
            int u = q.front();
            q.pop();
            for (int v = 1; v <= n; ++v) if (!trace[v])
                {
                    long long w = getC(u, v);
                    if (!w)
                    {
                        trace[v] = u;
                        if (!r[v])
                        {
                            finish = v;
                            return;
                        }
                        q.push(r[v]);
                    }
                    if (d[v] > w)
                    {
                        d[v] = w;
                        arg[v] = u;
                    }
                }
        }
    }
    void subX_addY()
    {
        long long delta = inf;
        for (int v = 1; v <= n; ++v) if (trace[v] == 0 && d[v] < delta)
            {
                delta = d[v];
            }
        // Rotate
        fx[start] += delta;
        for (int v = 1; v <= n; ++v) if(trace[v])
            {
                int u = r[v];
                fy[v] -= delta;
                fx[u] += delta;
            }
            else d[v] -= delta;
        for (int v = 1; v <= n; ++v) if (!trace[v] && !d[v])
            {
                trace[v] = arg[v];
                if (!r[v])
                {
                    finish = v;
                    return;
                }
                q.push(r[v]);
            }
    }
    void Enlarge()
    {
        do
        {
            int u = trace[finish];
            int nxt = l[u];
            l[u] = finish;
            r[finish] = u;
            finish = nxt;
        }
        while (finish);
    }
    long long maximum_matching()
    {
        for (int u = 1; u <= n; ++u)
        {
            fx[u] = c[u][1];
            for (int v = 1; v <= n; ++v)
            {
                fx[u] = min(fx[u], c[u][v]);
            }
        }
        for (int v = 1; v <= n; ++v)
        {
            fy[v] = c[1][v] - fx[1];
            for (int u = 1; u <= n; ++u)
            {
                fy[v] = min(fy[v], c[u][v] - fx[u]);
            }
        }
        for (int u = 1; u <= n; ++u)
        {
            start = u;
            initBFS();
            while (!finish)
            {
                findAugPath();
                if (!finish) subX_addY();
            }
            Enlarge();
        }
        long long ans = 0;
        for (int i = 1; i <= n; ++i)
        {
            if (c[i][l[i]] != inf) ans += c[i][l[i]];
            else l[i] = 0;
        }
        return ans;
    }
};
const int N = 1e5 + 5;

bitset<N> bt1[M];
bitset<N> bt2[M];
int n,m;
int a[N];
int b[N];
int w[M][M];
int mp[M];

int getFlow()
{
    Hungarian h(m,m);
    for(int i=1;i<=m;i++)
    {
        for(int j=1;j<=m;j++)
        {
            h.add_edge(i,j,-w[i][j]);
        }
    }
    return -h.maximum_matching();
}

vector<int>all;
int getVal(int now, int &asol)
{
    int low = 0, high = (int)all.size()-1;
    int ans = -1;
    while(low <= high)
    {
        int mid = (low + high)/2;
        int bostu = all[mid];

        Hungarian h(m,m);
        for(int i=1;i<=m;i++)
        {
            if(mp[i]!=-1)
            {
                h.add_edge(i,mp[i],-w[i][mp[i]]);
            }
            else if(i==now)
            {
                for(int jj=0;jj<=mid;jj++)
                {
                    int j = all[jj];
                    h.add_edge(i,j,-w[i][j]);
                }
            }
            else{
                for(int j:all)
                {
                    h.add_edge(i,j,-w[i][j]);
                }
            }
        }
        int eta = -h.maximum_matching();
        if(eta == asol)
        {
            ans = all[mid];
            high = mid-1;
        }
        else{
            low = mid+1;
        }
    }
    assert(ans!=-1);
    return ans;
}

void TEST_CASES()
{
    cin>>n>>m;
    for(int i=1; i<=n; i++)
    {
        cin>>a[i];
        bt1[a[i]][i] = 1;
    }
    for(int i=1; i<=n; i++)
    {
        cin>>b[i];
        bt2[b[i]][i] = 1;
    }
    for(int i=1; i<=m; i++)
    {
        for(int j=1; j<=m; j++)
        {
            int now = (bt1[i] & bt2[j]).count();
            w[i][j] = now;
        }
    }
    int ans = getFlow();

    memset(mp,-1,sizeof mp);


    for(int i=1;i<=m;i++)
        all.push_back(i);

    for(int i=1;i<=n;i++)
    {
        int now = a[i];
        if(mp[now]!=-1)
            continue;

        int x = getVal(now, ans);
        int flag = 0;

        for(int j=0;j<all.size();j++)
        {
            if(all[j]==x)
            {
                all.erase(all.begin() + j);
                flag = 1;
                break;
            }
        }
        assert(flag);
        mp[now] = x;
    }
    for(int i=1;i<=n;i++)
        cout<<mp[a[i]]<<" ";


}


/*
*/

int32_t main()
{
#ifndef APURBA
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
#endif
    //freopen("input.txt","r",stdin);
    //freopen("out1.txt","w",stdout);
    int t=1;
    //cin>>t;
    while(t--)
    {
        TEST_CASES();
    }
    return 0;
}