#pragma GCC optimize("O3")
#include <bits/stdc++.h>
using namespace std;
#define all(arr) (arr).begin(), (arr).end()
#define ll long long
#define ld long double
#define pb push_back
#define sz(x) (int)(x).size()
#define fi first
#define se second
#define endl '\n'

const int N = 1e5 + 20;

int nodeidx = 0;
int root[N];

struct Node{
  int lidx, ridx;
  int sum;
  
  Node(){
    sum = 0;
    lidx = ridx = -1;
  };

  Node(int val){
    sum = val;
    lidx = ridx = -1;
  };

  Node(int lidx1, int ridx1, int sum1){
    lidx = lidx1, ridx = ridx1;
    sum = sum1;
  };
};

Node nodes[N * 100];

int make_node(){
  nodes[nodeidx] = Node();
  return nodeidx++;
}

int make_node(int val){
  nodes[nodeidx] = Node(val);
  return nodeidx++;
}

int make_node(int lidx, int ridx){
  nodes[nodeidx] = Node(lidx, ridx, nodes[lidx].sum + nodes[ridx].sum);
  return nodeidx++;
}

int inc(int v, int tl, int tr, int idx, int val){
  if (tl == tr){
    return make_node(nodes[v].sum + val);
  }
  int tm = (tl + tr) / 2;
  if (idx <= tm) return make_node(inc(nodes[v].lidx, tl, tm, idx, val), nodes[v].ridx);
  else return make_node(nodes[v].lidx, inc(nodes[v].ridx, tm + 1, tr, idx, val));
}

int build(int tl, int tr){
  if (tl == tr) return make_node();
  int tm = (tl + tr) / 2;
  return make_node(build(tl, tm), build(tm + 1, tr));
}

int rsq(int v, int tl, int tr, int l, int r){
  if (l > r) return 0;
  if (tl == l && tr == r) return nodes[v].sum;
  int tm = (tl + tr) / 2;
  return rsq(nodes[v].lidx, tl, tm, l, min(r, tm)) + 
  rsq(nodes[v].ridx, tm + 1, tr, max(l, tm + 1), r);
}

int n;

int getsmaller(int l, int r, int val){
  return rsq(root[r], 0, n - 1, 0, val - 1) - rsq(root[l - 1], 0, n - 1, 0, val - 1);
}

int getlarger(int l, int r, int val){
  return rsq(root[r], 0, n - 1, val + 1, n - 1) - rsq(root[l - 1], 0, n - 1, val + 1, n - 1);
}

int a[N], segend[N];
ll invcnt[N];

void solve(){
  cin >> n;
  for (int i = 0; i <= n + 1; i++) a[i] = segend[i] = invcnt[i] = 0;
  nodeidx = 0;
  for (int i = 1; i <= n; i++){
    cin >> a[i];
    a[i]--;
  }
  root[0] = build(0, n - 1);
  for (int i = 1; i <= n; i++){
    root[i] = inc(root[i - 1], 0, n - 1, a[i], 1);
  }
  set<int> starts;
  multiset<ll> answers;
  starts.insert(1);

  auto calc_invs = [&] (int l, int r){
    ll ret = 0;
    for (int i = l; i <= r; i++){
      ret += getlarger(l, i - 1, a[i]);
    }
    return ret;
  };

  invcnt[1] = calc_invs(1, n);
  answers.insert(invcnt[1]);
  segend[1] = n;

  for (int idx = 0; idx < n; idx++){
    ll z = *prev(answers.end());
    cout << z << " ";

    ll i;
    cin >> i;
    i ^= z;
    int start = *prev(starts.upper_bound(i));
    int fin = segend[start];
    ll valbef = invcnt[start] - getlarger(start, i - 1, a[i]) - getsmaller(i + 1, fin, a[i]);
    int len1 = i - start, len2 = fin - i;
    if (len1 < len2){
      ll ourans = calc_invs(start, i - 1);
      ll crossans = 0;
      for (int j = start; j < i; j++){
        crossans += getsmaller(i + 1, fin, a[j]);
      }
      answers.erase(answers.find(invcnt[start]));

      invcnt[start] = ourans;
      segend[start] = i - 1;

      invcnt[i + 1] = valbef - ourans - crossans;
      segend[i + 1] = fin;
      starts.insert(i + 1);

      answers.insert(invcnt[start]);
      answers.insert(invcnt[i + 1]);
    }
    else{
      ll ourans = calc_invs(i + 1, fin);
      ll crossans = 0;
      for (int j = i + 1; j <= fin; j++){
        crossans += getlarger(start, i - 1, a[j]);
      }
      answers.erase(answers.find(invcnt[start]));

      invcnt[start] = valbef - ourans - crossans;
      segend[start] = i - 1;

      invcnt[i + 1] = ourans;
      segend[i + 1] = fin;
      starts.insert(i + 1);

      answers.insert(invcnt[start]);
      answers.insert(invcnt[i + 1]);
    }
  }
  cout << endl;
}

signed main(){
  ios_base::sync_with_stdio(0);
  cin.tie(0);
  // cout.precision(20);
  int t;
  cin >> t;
  while (t--){
    solve();
  }
}