#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(100005);
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 = 0;
    vector<ordered_set<pii>> S(n+1);
    for(int i = 0; i < n; i++) S[0].insert({a[i], i});
    for(int _ = 0; _ < n; _++){
        assert(!freq.empty());
        z = freq.rbegin()->first;
        cout<<z;
        if(_ != n-1) cout<<" ";
        lint 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;
        freq[T]--;
        if(freq[T] == 0) freq.erase(T);
        inv.erase(it);
        int sz_left = p - l;
        int sz_right = r - (p+1) + 1;

        if(l == r){}
        else if(sz_left < sz_right){
            lint inv_lef = count_inv(l, p-1);
            lint inv_right = T - count_inv(l, p);
            ordered_set<pii> small;
            ordered_set<pii> &big = S[l];
            for(int i = l; i<=p; i++){
                small.insert({a[i], i});
                big.erase({a[i], i});
            }
            
            for(int i = l; i<=p; i++){
                inv_right -= big.order_of_key({a[i], -1});
            }
            small.erase({a[p], p});
            if(p+1 <= r){
                S[p+1].swap(big);
                inv[{p+1, r}] = inv_right;
                freq[inv_right]++;
            }
            if(l <= p-1){
                S[l] = small;
                inv[{l, p-1}] = inv_lef;
                freq[inv_lef]++;
            }

        } else {
            lint inv_right = count_inv(p+1, r);
            lint inv_lef = T - count_inv(p, r);
            ordered_set<pii> small;
            ordered_set<pii> &big = S[l];
            for(int i = p; i<=r; i++){
                small.insert({a[i], i});
                big.erase({a[i], i});
            }
          
            for(int i = p; i<=r; i++){
                inv_lef -= sz_left - big.order_of_key({a[i], inf});
            }
          
            small.erase({a[p], p});
            //S[l].swap(big);cout
            if(l <= p-1){
                inv[{l, p-1}] = inv_lef;
                freq[inv_lef]++;
            }
            if(p+1 <= r){
                S[p+1] = small;
                inv[{p+1, r}] = inv_right;
                freq[inv_right]++;
            }
        }
     
    } 
    cout<<"\n";
}

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