#include <bits/stdc++.h>
using namespace std;
struct binary_indexed_tree{
  int N;
  vector<int> BIT;
  binary_indexed_tree(){
  }
  binary_indexed_tree(int N): N(N), BIT(N + 1, 0){
  }
  void add(int i, int x){
    i++;
    while (i <= N){
      BIT[i] += x;
      i += i & -i;
    }
  }
  int sum(int i){
    int ans = 0;
    while (i > 0){
      ans += BIT[i];
      i -= i & -i;
    }
    return ans;
  }
  int sum(int L, int R){
    return sum(R) - sum(L);
  }
};
int main(){
  ios_base::sync_with_stdio(false);
  cin.tie(nullptr);
  int T;
  cin >> T;
  for (int i = 0; i < T; i++){
    int n;
    cin >> n;
    vector<int> a(n);
    for (int j = 0; j < n; j++){
      cin >> a[j];
      a[j]--;
    }
    vector<long long> inv(n, 0);
    vector<vector<int>> num(n);
    vector<binary_indexed_tree> BIT(n);
    set<pair<int, int>> st1;
    multiset<long long> st2;
    auto compress = [&](int l, int r){
      vector<int> b;
      for (int j = l; j < r; j++){
        b.push_back(a[j]);
      }
      sort(b.begin(), b.end());
      b.erase(unique(b.begin(), b.end()), b.end());
      for (int j = l; j < r; j++){
        a[j] = lower_bound(b.begin(), b.end(), a[j]) - b.begin();
      }
      return b;
    };
    st1.insert(make_pair(0, n));
    num[0] = compress(0, n);
    int m = num[0].size();
    BIT[0] = binary_indexed_tree(m);
    for (int j = 0; j < n; j++){
      inv[0] += BIT[0].sum(a[j] + 1, m);
      BIT[0].add(a[j], 1);
    }
    st2.insert(0);
    st2.insert(inv[0]);
    long long z;
    for (int j = 0; j < n; j++){
      z = *prev(st2.end());
      cout << z;
      if (j < n - 1){
        cout << ' ';
      }
      long long p;
      cin >> p;
      p ^= z;
      p--;
      auto itr = prev(st1.lower_bound(make_pair(p + 1, 0)));
      int L = (*itr).first;
      int R = (*itr).second;
      st1.erase(make_pair(L, R));
      st1.insert(make_pair(L, p));
      st1.insert(make_pair(p + 1, R));
      st2.erase(st2.find(inv[L]));
      if (p - L < R - 1 - p){
        swap(inv[L], inv[p + 1]);
        swap(num[L], num[p + 1]);
        swap(BIT[L], BIT[p + 1]);
        for (int k = L; k <= p; k++){
          BIT[p + 1].add(a[k], -1);
        }
        for (int k = L; k <= p; k++){
          inv[p + 1] -= BIT[p + 1].sum(a[k]);
        }
        if (L < p){
          for (int k = L; k < p; k++){
            if (a[k] > a[p]){
              inv[p + 1]--;
            }
          }
          num[L] = compress(L, p);
          m = num[L].size();
          BIT[L] = binary_indexed_tree(m);
          for (int k = L; k < p; k++){
            inv[L] += BIT[L].sum(a[k] + 1, m);
            BIT[L].add(a[k], 1);
          }
          inv[p + 1] -= inv[L];
          st2.insert(inv[L]);
        }
        st2.insert(inv[p + 1]);
      } else {
        for (int k = p; k < R; k++){
          BIT[L].add(a[k], -1);
        }
        for (int k = p; k < R; k++){
          inv[L] -= BIT[L].sum(a[k] + 1, num[L].size());
        }
        if (p + 1 < R){
          for (int k = p + 1; k < R; k++){
            if (a[p] > a[k]){
              inv[L]--;
            }
          }
          num[p + 1] = compress(p + 1, R);
          m = num[p + 1].size();
          BIT[p + 1] = binary_indexed_tree(m);
          for (int k = p + 1; k < R; k++){
            inv[p + 1] += BIT[p + 1].sum(a[k] + 1, m);
            BIT[p + 1].add(a[k], 1);
          }
          inv[L] -= inv[p + 1];
          st2.insert(inv[p + 1]);
        }
        if (L < p){
          st2.insert(inv[L]);
        }
      }
    }
    cout << '\n';
  }
}