#include<bits/stdc++.h>
#include<bits/extc++.h>

using namespace std;

using lint = int64_t;


template<typename K, typename V, typename Comp = less<K>>
using ordered_map = __gnu_pbds::tree<K, V, Comp, __gnu_pbds::rb_tree_tag, __gnu_pbds::tree_order_statistics_node_update>;

template<typename K, typename Comp = less<K>>
using ordered_set = ordered_map<K, __gnu_pbds::null_type, Comp>;

template<typename T> struct FT {
    vector<T> s;
    FT(int n=0) : s(n) {}
    FT(const vector<T> &A) : s(int(A.size())) {
        const int N = int(A.size());
        for(int pos = 0; pos < N; ++pos) {
            s[pos] += A[pos];
            int nxt = (pos | (pos + 1));
            if(nxt < N) s[nxt] += s[pos];
        }
    }

    void update(int pos, T dif) {
        for(; pos < (int) s.size(); pos |= pos + 1) s[pos] += dif;
    }

    T query(int pos) {
        T res = 0;
        for(; pos > 0; pos &= pos - 1) res += s[pos-1];        
        return res;
    }
};

FT<lint> ft(2000005);
vector<lint> a;

lint count_inv(int l, int r){
    if(l >= r) return 0;
    lint t = 0;
    for(int i = r; i>=l; i--){
        t += ft.query(a[i]);
        ft.update(a[i], 1);
    }
    for(int i = r; i>=l; i--){
        ft.update(a[i], -1);
    }
    return t;
}

using pii = pair<int, int>;

const int inf = 1e7;

void solve(){
    int n;
    cin>>n;
    a.resize(n);
    for(auto &x : a) cin>>x;
    map<pair<int, int>, lint> inv;
    map<lint, int> freq;
    inv[{0, n-1}] = count_inv(0, n-1);
    freq[inv[{0, n-1}]]++;
    lint z = inv[{0, n-1}];
    for(int _ = 0; _ < n; _++){
        assert(!freq.empty());
        z = freq.rbegin()->first;
        cout<<z;
        if(_ != n-1) cout<<" ";
        int p; cin>>p;
        p = p ^ z;
        p--;
        auto it = inv.upper_bound({p+1, -1});
        assert(it != inv.begin());
        it--;
        auto [interval, T] = *it;
        auto [l, r] = interval;
        //cout<<"querying "<<p<<endl;
        //cout<<"interval "<<l<<" "<<r<<" "<<T<<endl;
        freq[T]--;
        if(freq[T] == 0) freq.erase(T);
        inv.erase({l, r});
        for(int i = l; i<p; i++) if(a[i] > a[p]) T--;
        for(int i = p+1;i<=r; i++) if(a[i] < a[p]) T--;
        if(l == r) continue;
        if(p == l){
            lint inv_right = T;
            inv[{l+1, r}] = inv_right;
            freq[inv_right]++;
            continue;
        } 
        if(p == r){
            lint inv_lef = T;
            inv[{l, r-1}] = inv_lef;
            freq[inv_lef]++;
            continue;
        } 
        int sz_left = p - l;
        int sz_right = r - (p+1) + 1;
        
        if(sz_left < sz_right){
            lint inv_lef = count_inv(l, p-1);
            lint inv_right = T - inv_lef;
            ordered_set<pii> S;
            for(int i = l; i<p; i++){
                S.insert({a[i], i});
            }
            int L = S.size();
            for(int i = p+1; i<=r; i++){
                inv_right -= L - S.order_of_key({a[i], inf});
            }
            inv[{l, p-1}] = inv_lef;
            inv[{p+1, r}] = inv_right;
            freq[inv_lef]++;
            freq[inv_right]++;
        } else {
            lint inv_right = count_inv(p+1, r);
            lint inv_lef = T - inv_right;
            ordered_set<pii> S;
            for(int i = p+1; i<=r; i++){
                S.insert({a[i], i});
            }
            for(int i = l; i<p; i++){
                inv_lef -= S.order_of_key({a[i], -1});
            }
            inv[{l, p-1}] = inv_lef;
            inv[{p+1, r}] = inv_right;
            freq[inv_lef]++;
            freq[inv_right]++;
        }
        // for(auto [interval, T] : inv){
        //     //cout<<"( " <<interval.first<<", "<<interval.second<<") "<<T<<endl;
        // }
        //cout<<endl;
    } 
    cout<<"\n";
    //cout<<"-----"<<endl;
}

int main() {
    cin.tie(nullptr)->sync_with_stdio(false);
    int t; cin>>t;
    while(t--){
        solve();
    }
    return 0;
}