#include <bits/stdc++.h>

#include <bits/extc++.h> // pbds
using namespace __gnu_pbds;

using namespace std;

#define int long long

#define F(i, a, b) for (int i = a; i < b; i++)
#define ALL(x) x.begin(), x.end()
#define IOS ios_base::sync_with_stdio(0)

typedef vector<int> vi;
typedef vector<vector<int>> vvi;
typedef pair<int, int> ii;
typedef vector<ii> vii;
typedef long long ll;

typedef tree<ii, null_type, less<ii>, rb_tree_tag,
             tree_order_statistics_node_update>
    ost;

vector<int> a;

const int N = 1e5 + 10;

#define lson rt << 1
#define rson rt << 1 | 1
#define int_mid int mid = (segTree[rt].l + segTree[rt].r) >> 1

ll b[N];

struct node {
  int l, r;
  ll val, lazy;
} segTree[N * 4];

ll helper(int l, int mid, int r) {
  ll ans = 0;
  ost found;
  F(i, l, mid + 1) { found.insert({a[i], i}); }
  F(i, mid + 1, r + 1) { ans += found.size() - found.order_of_key({a[i], i}); }

  // cout << l << ' ' << mid << ' ' << r << ' ' << ans << endl;

  return ans;
}

void push_up(int rt) {
  segTree[rt].val = segTree[lson].val + segTree[rson].val;
  segTree[rt].val += helper(segTree[rt].l, segTree[lson].r, segTree[rt].r);
}

void build(int rt, int l, int r) {
  segTree[rt].l = l, segTree[rt].r = r;
  segTree[rt].lazy = 0;
  if (l == r) {
    segTree[rt].val = 0;
    return;
  } else {
    int mid = (l + r) >> 1;
    build(lson, l, mid);
    build(rson, mid + 1, r);
    push_up(rt);
  }
}

ll query_interval(int rt, int l, int r) {
  if (l > r)
    return 0;
  if (l <= segTree[rt].l && r >= segTree[rt].r)
    return segTree[rt].val;
  int_mid;
  if (r <= mid)
    return query_interval(lson, l, r);
  else if (l > mid)
    return query_interval(rson, l, r);

  return query_interval(lson, l, mid) + query_interval(rson, mid + 1, r) +
         helper(l, mid, r);
}

ll inversions(int l, int r) { return query_interval(1, l, r); }

signed main() {
  IOS;
  cin.tie(0), cout.tie(0);

  int t, n;
  cin >> t;
  while (t--) {
    cin >> n;
    a.resize(n);
    F(i, 0, n) { cin >> a[i]; }
    vi z(n);
    F(i, 0, n) { cin >> z[i]; }
    build(1, 0, n - 1);

    // cout << inversions(0, 1) << endl;
    // cout << inversions(0, 2) << endl;
    // cout << inversions(1, 3) << endl;
    // cout << inversions(2, 4) << endl;

    map<ii, ll> values;
    set<pair<ll, ii>> sorted;
    set<int> removed({-1, n});

    values[{0, n}] = inversions(0, n);
    sorted.insert({values[{0, n}], {0, n}});
    ll ans = sorted.rbegin()->first;
    cout << ans << ' ';
    F(i, 0, n - 1) {
      z[i] ^= ans;

      int mid = z[i] - 1;
      auto it = removed.upper_bound(mid);
      int r = *it, l = *(--it) + 1;
      // cout << l << ' ' << mid << ' ' << r << endl;
      sorted.erase({values[{l, r}], {l, r}});
      values.erase({l, r});
      removed.insert(mid);

      ll val1 = inversions(l, mid - 1), val2 = inversions(mid + 1, r - 1);
      // cout << l << ' ' << mid - 1 << ' ' << val1 << endl;
      // cout << mid + 1 << ' ' << r - 1 << ' ' << val2 << endl;
      values[{l, mid}] = val1, sorted.insert({val1, {l, mid}});
      values[{mid + 1, r}] = val2, sorted.insert({val2, {mid + 1, r}});

      ans = sorted.rbegin()->first;
      cout << ans << ' ';
    }
    cout << '\n';
  }
}