#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

const int N = 1e5 + 10;
const int B = 700;
const int M = N / B + 10;

struct fenwick1d {
    int t[N];
    void update(int pos, int val) {
        for (int i = pos; i < N; i = i | (i + 1)) {
            t[i] += val;
        }
    }
    int get_pref_sum(int pref) {
        int res = 0;
        for (int i = pref; i >= 0; i = (i & (i + 1)) - 1) {
            res += t[i];
        }
        return res;
    }
    int get(int l, int r) {
        if (l > r) return 0;
        else if (l == 0) return get_pref_sum(r);
        else return get_pref_sum(r) - get_pref_sum(l - 1);
    }
};

struct fenwick1d_small {
    static const int N = B + 10;
    int t[N];
    void update(int pos, int val) {
        for (int i = pos; i < N; i = i | (i + 1)) {
            t[i] += val;
        }
    }
    int get_pref_sum(int pref) {
        int res = 0;
        for (int i = pref; i >= 0; i = (i & (i + 1)) - 1) {
            res += t[i];
        }
        return res;
    }
    int get(int l, int r) {
        if (l > r) return 0;
        else if (l == 0) return get_pref_sum(r);
        else return get_pref_sum(r) - get_pref_sum(l - 1);
    }
};

fenwick1d tree;
fenwick1d_small tree_small;

int a[N];
ll p[N];
ll ans[N];
int l_id[N], r_id[N];
int lef[N], rig[N];
ll mem_lef[M][N], mem_rig[M][N];

pair<int, int> b[N];
int pos[N];
int flag[N];

ll get(int l, int r) {
    if (l == lef[l]) {
        return mem_lef[l_id[l]][r];
    } else if (r == rig[r]) {
        return mem_rig[r_id[r]][l];
    } else if (lef[l] == lef[r]) {
        ll res = 0;
        int L = lef[l];
        for (int i = l; i <= r; i++) {
            res += tree_small.get(pos[i] - L + 1, rig[l] - lef[l] + 1);
            tree_small.update(pos[i] - L + 1, 1);
        }
        for (int i = l; i <= r; i++) {
            tree_small.update(pos[i] - L + 1, -1);
        }
        return res;
    } else {
        int L = l == lef[l] ? l : rig[l] + 1;
        int R = r == rig[r] ? r : lef[r] - 1;
        ll res = 0;
        if (L <= R) {
            res += mem_lef[l_id[L]][r] + mem_rig[r_id[R]][l] - mem_lef[l_id[L]][R];
        } else {
            res += mem_rig[r_id[rig[l]]][l] + mem_lef[l_id[lef[r]]][r];
        }
        // cout << l << " " << L << " " << R << " " << r << " " << res << "\n";
        for (int i = l; i <= L - 1; i++) {
            flag[pos[i]]++;
        }
        for (int i = R + 1; i <= r; i++) {
            flag[pos[i]]++;
        }
        int x = lef[l], y = lef[r];
        int cnt_lef = 0, cnt_rig = 0;
        while (x <= rig[l] && y <= rig[r]) {
            if (b[x].first <= b[y].first) {
                res += 1ll * flag[x] * cnt_rig;
                cnt_lef += flag[x];
                x++;
            } else {
                cnt_rig += flag[y];
                y++;
            }
        }
        while (x <= rig[l]) {
            res += 1ll * flag[x] * cnt_rig;
            cnt_lef += flag[x];
            x++;
        }
        while (y <= rig[r]) {
            cnt_rig += flag[y];
            y++;
        }
        for (int i = l; i <= L - 1; i++) {
            flag[pos[i]]--;
        }
        for (int i = R + 1; i <= r; i++) {
            flag[pos[i]]--;
        }
        return res;
    }
}

ll slow_get(int l, int r) {
    ll res = 0;
    for (int i = l; i <= r; i++) {
        for (int j = i + 1; j <= r; j++) {
            res += a[i] > a[j];
        }
    }
    return res;
}

void precalc(int n) {
    for (int i = 1; i <= n; i++) {
        l_id[i] = r_id[i] = 0;
    }
    for (int l = 1; l <= n; l += B) {
        int r = min(n, l + B - 1);
        l_id[l] = r_id[r] = (l + B - 1) / B;
        for (int i = l; i <= r; i++) {
            lef[i] = l;
            rig[i] = r;
        }
        mem_lef[l_id[l]][l - 1] = 0;
        for (int i = l; i <= n; i++) {
            mem_lef[l_id[l]][i] = mem_lef[l_id[l]][i - 1] + tree.get(a[i] + 1, n);
            tree.update(a[i], 1);
        }
        for (int i = l; i <= n; i++) {
            tree.update(a[i], -1);
        }
        mem_rig[r_id[r]][r + 1] = 0;
        for (int i = r; i >= 1; i--) {
            mem_rig[r_id[r]][i] = mem_rig[r_id[r]][i + 1] + tree.get(1, a[i] - 1);
            tree.update(a[i], 1);
        }
        for (int i = r; i >= 1; i--) {
            tree.update(a[i], -1);
        }
        for (int i = l; i <= r; i++) {
            b[i] = {a[i], i};
        }
        sort(b + l, b + r + 1);
        for (int i = l; i <= r; i++) {
            pos[b[i].second] = i;
        }
    }
}

void solve(int n) {
    precalc(n);

//    for (int len = 1; len <= n; len++) {
//        for (int l = 1; l + len - 1 <= n; l++) {
//            int r = l + len - 1;
//            if (get(l, r) != slow_get(l, r)) {
//                cout << l << " " << r << " " << get(l, r) << " " << slow_get(l, r) << "\n";
//                return;
//            }
//        }
//    }

    multiset<ll> ms;
    ms.insert(get(1, n));
    set<int> dead;
    dead.insert(0);
    dead.insert(n + 1);
    for (int i = 1; i <= n; i++) {
        ans[i] = *ms.rbegin();
        p[i] ^= ans[i];
        // cout << i << " " << ans[i] << " " << p[i] << "\n";
        if (1 > p[i] || p[i] > n || dead.count(p[i])) {
            cout << "DEAD\n";
            break;
        }
        // assert(1 <= p[i] && p[i] <= n && !dead.count(p[i]));
        int l, r;
        auto it = dead.lower_bound(p[i]);
        r = *it - 1;
        it--;
        l = *it + 1;
        ms.erase(ms.find(get(l, r)));
        if (l < p[i]) {
            // cout << "? " << l << " " << p[i] - 1 << " " << get(l, p[i] - 1) << "\n";
            ms.insert(get(l, p[i] - 1));
        }
        if (p[i] < r) {
            // cout << "? " << p[i] + 1 << " " << r << " " << get(p[i] + 1, r) << "\n";
            ms.insert(get(p[i] + 1, r));
        }
        dead.insert(p[i]);
    }
}

void stress() {
    mt19937 rnd;
    while (true) {
        int n = rnd() % 10 + 1;
        for (int i = 1; i <= n; i++) {
            a[i] = rnd() % n + 1;
        }
        precalc(n);
        int p = 0, q = 0;
        for (int len = 1; len <= n; len++) {
            for (int l = 1; l + len - 1 <= n; l++) {
                int r = l + len - 1;
                if (get(l, r) != slow_get(l, r)) {
                    p = l;
                    q = r;
                }
            }
        }
        if (p == 0) {
            cout << "OK" << endl;
        } else {
            cout << "WA\n";
            cout << "1\n";
            cout << n << "\n";
            for (int i = 1; i <= n; i++) {
                cout << a[i] << " ";
            }
            cout << "\n";
            for (int i = 1; i <= n; i++) {
                cout << i << " ";
            }
            cout << "\n\n";
            cout << p << " " << q << "\n";
            cout << get(p, q) << " " << slow_get(p, q) << "\n";
            break;
        }
    }
    exit(0);
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
#ifdef LOCAL
    freopen("input.txt", "r", stdin);
#endif

    // stress();

    // cout << sizeof(mem_lef) / (1 << 20) << "\n";

    int t;
    cin >> t;
    while (t--) {
        int n;
        cin >> n;
        for (int i = 1; i <= n; i++) {
            cin >> a[i];
        }
        for (int i = 1; i <= n; i++) {
            cin >> p[i];
        }
        solve(n);
        for (int i = 1; i <= n; i++) {
            cout << ans[i] << " ";
        }
        cout << "\n";
    }

#ifdef LOCAL
    cout << "\nTime elapsed: " << double(clock()) / CLOCKS_PER_SEC << " s.\n";
#endif
}