#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>

using namespace std;
using namespace __gnu_pbds;

#define PLL pair<long long, long long>
#define LL long long

#define faster {ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);}
#define ordered_multiset tree<int, null_type,less_equal<int>, rb_tree_tag,tree_order_statistics_node_update>
#define all(v) v.begin(),v.end()

const LL mod = 998244353;
const int N = 1e6 + 10;
LL inf = 1e17 + 1;


class PST{
    #define lc(u) tree[u].left
    #define rc(u) tree[u].right;
    struct node{
        int left = 0, right = 0, val = 0;
    };
    node *tree;
    int N, LG, time = 0, I = 0;

    node create(int l, int r){
        return {l, r, merge(tree[l].val, tree[r].val)};
    }
    int merge(LL a, LL b){ 
        return a + b;
    }
    int build(int le, int ri){
        int id = ++time;
        if(le == ri) return tree[id] = node(), id;
        int m = (le + ri) / 2;
        return tree[id] = create(build(le, m), build(m + 1, ri)), id;
    }
    int update(int id, int le, int ri, int pos, int val){
        int nid = ++time;
        if(le == ri) return tree[nid] = {0, 0, (tree[id].val + val)}, nid; // change here
        int m = (le + ri) / 2;
        if(pos <= m){
            tree[nid] = create(update(tree[id].left, le, m, pos, val), tree[id].right);
        }else{
            tree[nid] = create(tree[id].left, update(tree[id].right, m + 1, ri, pos, val));
        }
        return nid;
    }
    int query(int id, int le, int ri, int l, int r){
        if (l <= le && r >= ri) {
            return tree[id].val;
        }
        if (r < le || l > ri) {
            return I;
        }
        int m = (le + ri) >> 1;      
        return merge(query(tree[id].left, le, m, l, r), query(tree[id].right, m + 1, ri, l, r));
    }
    
public:
    PST(int N, int U){ // U --> number of expected updates
        this->N = N;
        LG = 33 - __builtin_clz(N);
        tree = new node[N * 4 + U * LG];
        build(0, N - 1); 
    }
    int update(int id, int pos, int val){
        return update(id, 0, N - 1, pos, val);
    }
    int query(int id, int l, int r){
        if(l > r) return I;
        return query(id, 0, N - 1, l, r);
    }
    ~PST(){
        delete[] tree;
    }
};

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

    multiset<LL> allInv;
    set<pair<int, int>> ranges; ranges.insert({1, n});
    vector<int> a(n + 1), root(n + 1);
    vector<LL> ansInRange(n + 1);
    LL ans = 0;
    PST tree(n + 10, n);
    for(int i = 1; i <= n; i++){
        cin>>a[i];
        int large = tree.query(root[i - 1], a[i] + 1, n);
        ans += large;
        root[i] = tree.update(root[i - 1], a[i], 1);
    }
    allInv.insert(ans);
    ansInRange[1] = ans;
    for(int i = 0; i < n; i++){
        LL p; cin>>p; 
        p ^= ans; 
        cout<<ans<<' ';
        
        auto [l, r] = *prev (ranges.upper_bound ({p, n}));
        allInv.erase(allInv.find(ansInRange[l]));
        ranges.erase({l, r});
        if(l == r) continue;
        if(r - p > p - l){
            LL left = 0, right = ansInRange[l];
            for(int j = l; j < p; j++){
                right -= (tree.query(root[r], 0, a[j] - 1) - tree.query(root[p - 1], 0, a[j] - 1));
                left += (tree.query(root[j], a[j] + 1, n) - tree.query(root[l - 1], a[j] + 1, n));
            }
            right -= (tree.query(root[r], 0, a[p] - 1) - tree.query(root[p - 1], 0, a[p] - 1));

            right -= left;

            ansInRange[l] = left;
            allInv.insert(ansInRange[l]); 
            if(p != r) ansInRange[p + 1] = right;
            if(p != r) allInv.insert(ansInRange[p + 1]);

        }else{
            LL left = ansInRange[l], right = 0;
            for(int j = p + 1; j <= r; j++){
                left -= (tree.query(root[p], a[j] + 1, n) - tree.query(root[l - 1], a[j] + 1, n));
                right += (tree.query(root[j], a[j] + 1, n) - tree.query(root[p], a[j] + 1, n));
            }
            left -= (tree.query(root[p], a[p] + 1, n) - tree.query(root[l - 1], a[p] + 1, n));

            left -= right;
            
            ansInRange[l] = left;
            allInv.insert(ansInRange[l]); 
            if(p != r) ansInRange[p + 1] = right;
            if(p != r) allInv.insert(ansInRange[p + 1]);
        }
        if(p > l)
            ranges.insert({l, p - 1});
        if(r > p)
            ranges.insert({p + 1, r});

        auto it = allInv.end(); it--;
        ans = *it;
    }
    cout<<'\n';
}

signed main() {  
    faster
    int t = 1;
    cin >> t;
    for (int tc = 1; tc <= t; tc++) {
        solve(tc);
    }
    return 0;
}