#include <iostream>
#include <stdio.h>
#include <cstring>
#include <vector>
#include <algorithm>
#include <cstdlib>
#include <cmath>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <ctime>
#include <cassert>
#include <unordered_map>
#include <fstream>
#include <random>
#include <cstring>
#include <bitset>
#include <functional>
#include <tuple>
#include <complex>
#include <chrono>
#include <climits>

#define all(a) (a).begin(), (a).end()
#define sz(a) (int)(a).size()

using namespace std;

typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef unsigned int uint;

mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
// default_random_engine generator;
// mt19937 rnd(1);

vector<int> operator*(const vector<int> &a, const vector<int> &b) {
    int n = sz(a);
    vector<int> res(n);
    for (int i = 0; i < n; ++i) {
        res[i] = a[b[i]];
    }
    return res;
}

vector<int> id(int n) {
    vector<int> res(n);
    for (int i = 0; i < n; ++i) {
        res[i] = i;
    }
    return res;
}

vector<int> binPow(vector<int> a, int m) {
    int n = sz(a);
    vector<int> res = id(n);
    for (; m > 0; m >>= 1) {
        if (m & 1) {
            res = res * a;
        }
        a = a * a;
    }
    return res;
}

vector<int> rev(const vector<int> &a) {
    int n = sz(a);
    vector<int> res(n);
    for (int i = 0; i < n; ++i) {
        res[a[i]] = i;
    }
    return res;
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);

    // freopen("input.txt", "r", stdin);
    // freopen("output.txt", "w", stdout);

    vector<int> u = {2, 1, 3, 0};
    // vector<int> v = {3, 0, 2, 1};
    vector<int> v = {2, 1, 3, 0};

    int n, k;
    cin >> n >> k;

    vector<int> p(n), q(n);
    for (int i = 0; i < n; ++i) {
        cin >> p[i];
        --p[i];
    }
    for (int j = 0; j < n; ++j) {
        cin >> q[j];
        --q[j];
    }

    --k;
    if (k == 0) {
        for (int el : p) {
            cout << el + 1 << " ";
        }
        cout << endl;
        return 0;
    } 
    if (k == 1) {
        for (int el : q) {
            cout << el + 1 << " ";
        }
        cout << endl;
        return 0;
    }

    int s = k + (k - 1) / 3;
    int a = (s + 1) / 2 + 1;
    int b = (s + 1) / 2 - 1;
    if (a + b > s) {
        --a;
    }

    vector<vector<int>> perm(4);
    perm[0] = p;
    perm[1] = rev(p);
    perm[2] = q;
    perm[3] = rev(q);

    vector<int> f = id(n); 
    vector<int> g = id(n);
    for (int i = 0; i < 4; ++i) {
        f = f * perm[u[i]];
        g = g * perm[v[i]];
    }

    f = binPow(f, a / 4);
    g = binPow(g, b / 4);

    for (int i = 0; i < a % 4; ++i) {
        f = f * perm[u[i]];
    }
    for (int i = 0; i < b % 4; ++i) {
        g = g * perm[v[i]];
    }

    vector<int> res = f * rev(g);

    for (int i = 0; i < n; ++i) {
        cout << res[i] + 1 << " ";
    }
    cout << endl;

    // int k;
    // cin >> k;

    // vector<vector<int>> w;
    // w.push_back({0});
    // w.push_back({2});

    // for (int i = 2; i < k; ++i) {
    //     vector<int> nxt = w.back();
    //     vector<int> arr = w[sz(w) - 2];
    //     for (int i = 0; i < sz(arr); ++i) {
    //         arr[i] ^= 1;
    //     }
    //     reverse(all(arr));

    //     for (int i = 0; i < sz(arr); ++i) {
    //         if ((arr[i] ^ nxt.back()) == 1) {
    //             nxt.pop_back();
    //         } else {
    //             nxt.push_back(arr[i]);
    //         }
    //     }

    //     w.push_back(nxt);
    // }


    // vector<int> u = {2, 1, 3, 0};
    // vector<int> v = {3, 0, 2, 1};

    // for (int i = 0; i < k; ++i) {
    //     int a = 0, b = 0;
    //     for (int j = 0; j < sz(w[i]); ++j) {
    //         if (w[i][j] != u[j % 4]) {
    //             break;
    //         }
    //         ++a;
    //     }
    //     reverse(all(w[i]));
    //     for (int j = 0; j < sz(w[i]); ++j) {
    //         if (w[i][j] != v[j % 4]) {
    //             break;
    //         }
    //         ++b;
    //     }
    //     reverse(all(w[i]));

    //     // cout << i << " " << sz(w[i]) << " " << a << " " << b << endl;

    //     int s = i + (i - 1) / 3;
    //     int aa = (s + 1) / 2 + 1;
    //     int bb = (s + 1) / 2 - 1;

    //     if (i >= 2) {
    //         assert(s == sz(w[i]));
    //         assert(a == aa);
    //         assert(b == bb);

    //     }
        

    //     // cout << i << " " << s << " " << aa << " " << bb << endl;
    // } 

    // for (int i = 0; i < k; ++i) {
    //     // if (i % 3 != 1) {
    //     //     continue;
    //     // }
    //     for (int el : w[i]) {
    //         cout << el << " ";
    //     }
    //     cout << endl;
    // }

    // int n, k;
    // cin >> n >> k;

    // vector<vector<int>> a(2, vector<int>(n));

    // for (int i = 0; i < 2; ++i) {
    //     for (int j = 0; j < n; ++j) {
    //         cin >> a[i][j];
    //         --a[i][j];
    //     }
    // } 

    // while (sz(a) < k) {
    //     int m = sz(a);
    //     a.push_back(vector<int>(n));

    //     vector<int> r(n);
    //     for (int i = 0; i < n; ++i) {
    //         r[a[m - 2][i]] = i;
    //     }

    //     for (int i = 0; i < n; ++i) {
    //         a[m][i] = a[m - 1][r[i]];
    //     }
    // }

    // for (int i = 0; i < n; ++i) {
    //     cout << a[k - 1][i] + 1 << " ";
    // }
    // cout << endl;


        

}


Measured memory_bytes: 5004