#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int n, idx;
int arr[N], root[N];
struct node {
    int l, r;
    int cnt;
}tr[N * 4 + 20 * N];

map<int, long long> mp;
multiset<long long> ms;

int query(int cur, int l, int r, int ql, int qr) {
    if (ql > qr) return 0;
    if (l >= ql && r <= qr) return tr[cur].cnt;
    int mid = (l + r) >> 1, sum = 0;

    if (ql <= mid) sum += query(tr[cur].l, l, mid, ql, qr);
    if (qr > mid) sum += query(tr[cur].r, mid + 1, r, ql, qr);
    return sum;
}

int build(int l, int r) {
    int cur = ++idx;
    if (l == r) 
        return cur;
    
    int mid = (l + r) >> 1;
    tr[cur].l = build(l, mid), tr[cur].r = build(mid + 1, r);
    return cur;
}

int add(int p, int l, int r, int x) {
    int cur = ++idx;
    tr[cur] = tr[p];
    if (l == r) {
        tr[cur].cnt++;
        return cur;
    }

    int mid = (l + r) / 2;
    if (x <= mid) tr[cur].l = add(tr[p].l, l, mid, x);
    else tr[cur].r = add(tr[p].r, mid + 1, r, x);
    tr[cur].cnt = tr[tr[cur].l].cnt + tr[tr[cur].r].cnt;

    return cur;
}

void split(int L, int R, int X) {
    long long old = mp[L - 1]; ms.erase(ms.find(old));
    long long base = query(root[R], 1, n, 1, arr[X] - 1) - query(root[X], 1, n, 1, arr[X] - 1);
    base += query(root[X - 1], 1, n, arr[X] + 1, n) - query(root[L - 1], 1, n, arr[X] + 1, n);
    if (X - L < R - X) {
        long long a = 0, b = base;
        for (int i = L; i < X; i++) {
            a += query(root[i - 1], 1, n, arr[i] + 1, n) - query(root[L - 1], 1, n, arr[i] + 1, n);
            b += query(root[R], 1, n, 1, arr[i] - 1) - query(root[X], 1, n, 1, arr[i] - 1);
        }
        mp[L - 1] = a; ms.insert(mp[L - 1]);
        mp[X] = old - a - b; ms.insert(mp[X]);
    } else {
        long long a = 0, b = base;
        for (int i = X + 1; i <= R; i++) {
            a += query(root[i - 1], 1, n, arr[i] + 1, n) - query(root[X], 1, n, arr[i] + 1, n);
            b += query(root[X - 1], 1, n, arr[i] + 1, n) - query(root[L - 1], 1, n, arr[i] + 1, n);
        }
        mp[L - 1] = old - a - b; ms.insert(mp[L - 1]);
        mp[X] = a; ms.insert(mp[X]);
    }
}

void solve() {
    scanf("%d", &n);
    for (int i = 1; i <= n; i++) scanf("%d", &arr[i]);

    for (int i = 1; i <= idx; i++)
        tr[i] = {0, 0, 0};
    idx = 0;
    root[0] = build(1, n);
    for (int i = 1; i <= n; i++) root[i] = add(root[i - 1], 1, n, arr[i]);

    long long tmp = 0;
    for (int i = 1; i <= n; i++) tmp += query(root[i - 1], 1, n, arr[i] + 1, n);

    mp.clear(); ms.clear();
    mp[0] = tmp; ms.insert(tmp);
    mp[n + 1] = 0; ms.insert(0);

    long long ans = *prev(ms.end());
    for (int i = 1; i <= n; i++) {
        printf("%lld%c", ans, "\n "[i < n]);
        long long x; scanf("%lld", &x);
        x ^= ans;
        auto it = prev(mp.lower_bound(x));
        split(it->first + 1, next(it)->first - 1, x);
        ans = *prev(ms.end());
    }
}

int main() 
{
    int t; scanf("%d", &t);
    while (t--) solve();
    return 0;
}