#include <bits/stdc++.h>

#define el '\n'
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
const int N = 1e5 + 10, MAXP = 20;

class Plane {
    vector<int> q[N];
    struct Node {
        int lc, rc;
        ll v;
    }tr[N * (4 + MAXP)];
    int n, idx, root[N];
    void pushup(int u) {
        tr[u].v = tr[tr[u].lc].v + tr[tr[u].rc].v;
    }
    int build_tree(int l, int r) {
        int p = ++idx;
        if (l == r) return p;
        int mid = l + r >> 1;
        tr[p].lc = build_tree(l, mid), tr[p].rc = build_tree(mid + 1, r);
        return p;
    }
    int update(int p, int l, int r, int x, int v) {
        int q = ++idx;
        tr[q] = tr[p];
        if (l == r) {
            tr[q].v += v;
            return q;
        }
        int mid = l + r >> 1;
        if (x <= mid) tr[q].lc = update(tr[p].lc, l, mid, x, v);
        else tr[q].rc = update(tr[p].rc, mid + 1, r, x, v);
        pushup(q);
        return q;
    }
    ll query(int p, int l, int r, int ql, int qr) {
        if (l >= ql && r <= qr) return tr[p].v;
        int mid = l + r >> 1;
        ll res = 0;
        if (ql <= mid) res = query(tr[p].lc, l, mid, ql, qr);
        if (qr > mid) res += query(tr[p].rc, mid + 1, r, ql, qr);
        return res;
    }
  public:
    void clear(int n) {
        memset(tr, 0, (idx + 5) * sizeof(Node));
        memset(root, 0, (n + 5) * sizeof(int));
        idx = 0;
        this->n = n;
        for (int i = 1; i <= n; ++i) q[i].clear();
    }
    void add_point(int x, int y) {
        q[y].push_back(x);
    }
    void build() {
        root[0] = build_tree(1, n);
        for (int i = 1; i <= n; ++i) {
            root[i] = root[i - 1];
            for (auto x: q[i]) root[i] = update(root[i], 1, n, x, 1);
        }
    }
    ll get_sum(int L, int R, int D, int U) {
        return query(root[U], 1, n, L, R) - query(root[D - 1], 1, n, L, R);
    }
}plane;

struct Node {
    int l, r;
    mutable ll v;
    bool operator<(const Node &t) const{
        return l < t.l;
    }
};
set<Node> odt;

void solve() {
    int n;
    cin >> n;
    plane.clear(n + 1);
    vector<int> a(n + 1);

    for (int i = 1; i <= n; ++i) {
        cin >> a[i];
        plane.add_point(i, a[i]);
    }
    ll ans = 0;
    plane.build();
    for (int i = 1; i <= n; ++i) 
        ans += plane.get_sum(1, i, a[i] + 1, n + 1);
    cout << ans << ' ';
    multiset<ll> vals;
    odt.clear();
    odt.insert({1, n, ans});
    vals.insert(ans);

    auto wk = [&](int k) {
        ll res = 0;
        auto it = --odt.upper_bound({k});
        ll l = it->l, r = it->r, inv = it->v;
        odt.erase(it), vals.erase(vals.find(inv));
        inv -= plane.get_sum(l, k, a[k] + 1, n + 1);
        inv -= plane.get_sum(k, r, 0, a[k] - 1);
        if (l == r) return;
        if (k - l <= r - k) {
            ll invl = 0, invlr = 0, invr = 0;
            for (int i = l; i < k; ++i) {
                invl += plane.get_sum(l, i, a[i] + 1, n + 1);
                invlr += plane.get_sum(k + 1, r, 0, a[i] - 1);
            }
            invr = inv - invl - invlr;
            if (k > l) odt.insert({l, k - 1, invl}), vals.insert(invl);
            odt.insert({k + 1, r, invr}), vals.insert(invr);
        } else {
            ll invl = 0, invlr = 0, invr = 0;
            for (int i = k + 1; i <= r; ++i) {
                invr += plane.get_sum(k + 1, i, a[i] + 1, n + 1);
                invlr += plane.get_sum(l, k - 1, a[i] + 1, n + 1);
            }
            invl = inv - invr - invlr;
            if (k < r) odt.insert({k + 1, r, invr}), vals.insert(invr);
            odt.insert({l, k - 1, invl}), vals.insert(invl);
        }
    };

    for (int i = 1; i <= n; ++i) {
        ll k; cin >> k;
        if (i == n) break;
        k = k ^ ans;
        wk(k);
        ans = *vals.rbegin();
        cout << ans << ' ';
    }
    cout << el;
}

int main() {
    ios::sync_with_stdio(0); cin.tie(0);
    int tcase;
    cin >> tcase;
    while (tcase--) solve();
}