/**
 *  - Meet Brahmbhatt
 *  - Hard work always pays off
**/
#include"bits/stdc++.h"
using namespace std;

#include<ext/pb_ds/assoc_container.hpp>
#include<ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
typedef tree<pair<int, int>, null_type, less<pair<int, int>>, rb_tree_tag, tree_order_statistics_node_update> pbds;
//member functions :
//1. order_of_key(k) : number of elements strictly lesser than k
//2. find_by_order(k) : k-th element in the set


#ifdef MeetBrahmbhatt
#include "debug.h"
#else
#define dbg(...) 72
#endif

#define endl "\n"
#define ll long long

const long long INF = 4e18;

const int N = 1e5 + 10;

int a[N];
ll p[N];
pbds S[N];
int id[N];
int l[N], r[N];
ll cnt[N];

void solve() {
    int n;
    cin >> n;

    for (int i = 0; i <= n; i++) {
        S[i].clear();
        id[i] = 0;
    }
    for (int i = 1; i <= n; i++) {
        cin >> a[i];
    }
    for (int j = 1; j <= n; j++) {
        cin >> p[j];
    }

    auto get = [&] (int ID, int x, int val) {
        if (val == 1) {
            return (int) S[ID].size() - S[ID].order_of_key({x + 1, -1});
        } else {
            return S[ID].order_of_key({x, -1});
        }
    };

    ll inv = 0;
    for (int i = 1; i <= n; i++) {
        inv += get(id[i], a[i], 1);
        S[id[i]].insert({a[i], i});
    }

    l[0] = 1;
    r[0] = n;
    cnt[0] = inv;

    multiset<ll> ans = {inv};
    ll prv = inv;
    cout << prv << " \n"[n == 1];

    for (int i = 1; i < n; i++) {
        int rem = (prv ^ p[i]);
        assert(1 <= rem and rem <= n);
        int cur_id = id[rem];

        int L = l[cur_id];
        int R = r[cur_id];

        ll rem_inv = cnt[cur_id];
        ll cur_inv = 0;

        if (rem - L <= R - rem) {
            l[i] = L;
            r[i] = rem - 1;
            l[cur_id] = rem + 1;

            for (int j = L; j < rem; j++) {
                id[j] = i;
                int x = get(i, a[j], 1);
                cur_inv += x;
                S[i].insert({a[j], j});
                S[cur_id].erase({a[j], j});
            }
            for (int j = L; j <= rem; j++) {
                int x = get(cur_id, a[j], 0);
                rem_inv -= x;
            }
            S[cur_id].erase({a[rem], rem});
        } else {
            l[i] = rem + 1;
            r[i] = R;
            r[cur_id] = rem - 1;

            for (int j = rem + 1; j <= R; j++) {
                id[j] = i;
                int x = get(i, a[j], 1);
                cur_inv += x;
                S[i].insert({a[j], j});
                S[cur_id].erase({a[j], j});
            }
            for (int j = rem; j <= R; j++) {
                rem_inv -= get(cur_id, a[j], 1);
            }
            S[cur_id].erase({a[rem], rem});
        }
        rem_inv -= cur_inv;
        ans.erase(ans.find(cnt[cur_id]));

        cnt[i] = cur_inv;
        cnt[cur_id] = rem_inv;

        ans.insert(cur_inv);
        ans.insert(rem_inv);

        prv = *ans.rbegin();
        cout << prv << " \n"[i == n - 1];
    }
}

signed main() {
    cin.tie(0)->sync_with_stdio(0);
    cout << fixed << setprecision(9);
    int tt = 1;
    cin >> tt;
    while (tt--) solve();
    return 0;
}