#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 all(V) V.begin (), V.end ()

using LL = long long;
using ordered_multiset = tree<int, null_type, less_equal<int>, rb_tree_tag, tree_order_statistics_node_update>;

void solve (int tc) {
    int n; cin>>n;
    vector<int> a(n);
    ordered_multiset os[n + 1];
    multiset<LL> allInv;
    set<pair<int, int>> ranges; ranges.insert({0, n - 1});
    LL ans = 0;
    for(int i = 0; i < n; i++){
        cin>>a[i];
        int large = i - os[0].order_of_key(a[i] + 1);
        ans += large;
        os[0].insert(a[i]);
    }
        // cout<<ans<<'\n';
    allInv.insert(ans);
    allInv.insert(0);
    LL ansInRange[n] = {}; ansInRange[0] = ans;
    for(int i = 0; i < n; i++){
        LL p; cin>>p; 
        p ^= ans; 
        // cerr<<p<<" "<<ans<<'\n'; 
        cout<<ans<<' ';
        p--;
        // for(auto [L, R]: ranges) cerr<<"Time "<<i<<" Set e ase --> "<<L<<" "<<R<<'\n';
        auto [l, r] = *prev (ranges.upper_bound ({p, n}));
        // cerr<<"LR--> "<<l<<" "<<r<<" "<<p<<'\n';
        allInv.erase(allInv.find(ansInRange[l]));
        ranges.erase({l, r});
        if(l == r){
            // an
            continue;
        }
        if(p == r){
            ansInRange[l] -= (r - l + 1 - os[l].order_of_key(a[p] + 1));
            os[l].erase(os[l].find_by_order(os[l].order_of_key(a[p])));
            allInv.insert(ansInRange[l]);  //cout<<ansInRange[l]<<'\n';
            if(p > l) ranges.insert({l, p - 1});
            auto it = allInv.end(); it--;
            ans = *it;
            continue;
        }
        if(r - p > p - l){
            swap(os[l], os[p + 1]); 
            LL tmp = 0;
            for(int j = l; j < p; j++){
                os[p + 1].erase(os[p + 1].find_by_order(os[p + 1].order_of_key(a[j])));
                LL large = j - l - os[l].order_of_key(a[j] + 1);
                tmp += large;
                os[l].insert(a[j]);
            }
            for(int j = l; j < p; j++){
                LL small = os[p + 1].order_of_key(a[j]);
                ansInRange[l] -= small;
            }
            ansInRange[l] -= os[p + 1].order_of_key(a[p]);
            os[p + 1].erase(os[p + 1].find_by_order(os[p + 1].order_of_key(a[p])));
            ansInRange[p + 1] = ansInRange[l];
            ansInRange[l] = tmp;
            ansInRange[p + 1] -= ansInRange[l];

            allInv.insert(ansInRange[l]); 
            allInv.insert(ansInRange[p + 1]);
        }else{
            LL tmp = 0;
            // cout<<(r - l + 1)<<" "<<os[l].size()<<'\n';
            for(int j = p + 1; j <= r; j++){
                os[l].erase(os[l].find_by_order(os[l].order_of_key(a[j])));
                LL large = j - p - 1 - os[p + 1].order_of_key(a[j] + 1);
                tmp += large;
                os[p + 1].insert(a[j]);
            }
            // cout<<ansInRange[l]<<'\n';
            // cout<<os[l].size() <<" "<<p - l + 1<<'\n';
            for(int j = p + 1; j <= r; j++){
                LL large = (os[l].size()) - os[l].order_of_key(a[j] + 1);
                ansInRange[l] -= large;
            }
            ansInRange[l] -= (os[l].size()) - os[l].order_of_key(a[p] + 1);
            os[l].erase(os[l].find_by_order(os[l].order_of_key(a[p])));
            ansInRange[p + 1] = tmp;

            ansInRange[l] -= ansInRange[p + 1];
            allInv.insert(ansInRange[l]); //cout<<ansInRange[l]<<'\n';
            allInv.insert(ansInRange[p + 1]);
        }
        if(p > l)
            ranges.insert({l, p - 1});
        if(r > p)
            ranges.insert({p + 1, r});

        // for(auto ij: allInv) cerr<<ij<<" "; cerr<<'\n';
        auto it = allInv.end(); it--;
        ans = *it;
    }
    cout<<'\n';
} 

int main () {
    cin.tie (nullptr) -> ios_base :: sync_with_stdio (false);

    int tests = 1;
    cin >> tests;
    for (int tc = 1; tc <= tests; tc++) {
        solve (tc);
    }

    return 0;
}