#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp> 
#include <ext/pb_ds/detail/standard_policies.hpp>
using namespace __gnu_pbds;
using namespace std;
#define getbit(n, i) (((n) & (1LL << (i))) != 0) 
#define setbit0(n, i) ((n) & (~(1LL << (i)))) 
#define setbit1(n, i) ((n) | (1LL << (i))) 
#define togglebit(n, i) ((n) ^ (1LL << (i))) 
#define lastone(n) ((n) & (-(n))) 
char gap = 32;
 
#define int long long 
#define ll long long 
#define lll __int128_t
#define pb push_back
typedef tree<
pair<int, int>,
null_type,
less<pair<int, int>>,
rb_tree_tag,
tree_order_statistics_node_update>
ordered_set;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
ll hashPrime = 1610612741;
void solve() {
    int n; cin >> n;
    int a[n + 1]; 
    for(int i = 1; i <= n; i++) cin >> a[i];
    int contribution[n + 1];
    memset(contribution, 0, sizeof(contribution));

    vector<ordered_set> st(n + 1);
    for(int i = n; i >= 1; i--) {
        
        contribution[i] = st[1].order_of_key({a[i], -1});
        st[1].insert({a[i], i});
    
    }
    multiset<int, greater<int>> maxi;
    vector<int> ans(n + 1);
    for(int i = 1; i <= n; i++) {
        ans[1] += contribution[i];
    }
    
    maxi.insert(ans[1]);
    vector<int> p(n + 1); 
    multiset<pair<int, int>> ms;
    ms.insert({1, n});

    for(int i = 1; i <= n; i++) {
        cin >> p[i];
        int maxans = 0;
        if(!maxi.empty()) maxans = *maxi.begin();
        int idx = (p[i] ^ maxans);
        if(i > 1) cout << " ";
        cout << maxans;
        
        if(i == n) {
            break;
        }

        auto it = ms.upper_bound({idx, INT_MAX});
        it--;
        
        int l = it->first;  
        int r = it->second;
        
        ms.erase(it);
    
        int segment_ans = ans[l];
        maxi.erase(maxi.find(ans[l]));

        if(l == r) {
            ans[l] = 0;
            st[l].clear();
            continue;
        }


        if(idx - l < r - idx) {
            st[l].swap(st[idx + 1]);
            vector<pair<int, int>> temp;
            for(int i = l; i < idx; i++) {
                st[idx + 1].erase({a[i], i});
                temp.push_back({a[i], i});
            }
            int reduced = 0;
            for(int i = l; i <= idx; i++) {
                reduced += st[idx + 1].order_of_key({a[i], -1});
            }
            st[idx + 1].erase({a[idx], idx});
            segment_ans -= reduced;
            for(int i = idx - 1; i >= l; i--) {
                contribution[i] = st[l].order_of_key({a[i], -1});
                st[l].insert({a[i], i});
            }
            int left_ans = 0;
            for(int i = l; i < idx; i++) {
                left_ans += contribution[i];
            }
            if(idx > l) {
                ms.insert({l, idx - 1});
                ans[l] = left_ans;
                maxi.insert(ans[l]);
            }
            if(idx + 1 <= r) {
                ms.insert({idx + 1, r});
                ans[idx + 1] = segment_ans - left_ans;
                maxi.insert(ans[idx + 1]);
            }
            
        }
        else {
            vector<pair<int, int>> temp;
            for(int i = idx + 1; i <= r; i++) {
                st[l].erase({a[i], i});
                temp.push_back({a[i], i});
            }
            
            int reduced = 0;
            for(int i = idx; i <= r; i++) {
                reduced += ((int)st[l].size() - st[l].order_of_key({a[i], INT_MAX}));
            }
            st[l].erase({a[idx], idx});
            segment_ans -= reduced;
            for(int i = r; i > idx; i--) {
                contribution[i] = st[idx + 1].order_of_key({a[i], -1});
                st[idx + 1].insert({a[i], i});
            }
            int right_ans = 0;
            for(int i = idx + 1; i <= r; i++) {
                right_ans += contribution[i];
            }
            if(idx > l) {
                ms.insert({l, idx - 1});
                ans[l] = segment_ans - right_ans;
                maxi.insert(ans[l]);
            }
            if(idx + 1 <= r) {
                ms.insert({idx + 1, r});
                ans[idx + 1] = right_ans;
                maxi.insert(ans[idx + 1]);
            }
        } 

    }
    cout << "\n";
}
signed main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    int t; cin >> t;
    while(t--) {
        solve();
    }
}