#include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>

using namespace std;

typedef long long ll;

struct Fenwick2d {
  vector<vector<int>> coords;
  vector<vector<int>> vals;
  int n;

  Fenwick2d(int nn) {
    n = nn;
    coords.resize(n);
    vals.resize(n);
  }

  void fake_add(int x, int y) {
    for (int nx = x; nx < n; nx |= nx + 1) {
      for (int ny = y; ny <= n; ny |= ny + 1) {
        coords[nx].push_back(ny);
      }
    }
  }

  void compress() {
    for (int i = 0; i < n; ++i) {
      sort(coords[i].begin(), coords[i].end());
      coords[i].resize(unique(coords[i].begin(), coords[i].end()) -
                       coords[i].begin());
      vals[i].resize(coords[i].size());
    }
  }

  void add(int x, int y) {
    for (int nx = x; nx < n; nx |= nx + 1) {
      for (int ny = lower_bound(coords[nx].begin(), coords[nx].end(), y) -
                    coords[nx].begin();
           ny < (int)coords[nx].size(); ny |= ny + 1) {
        vals[nx][ny] += 1;
      }
    }
  }

  int get(int x, int y) {
    int ret = 0;
    for (int nx = x; nx >= 0; nx &= nx + 1, --nx) {
      for (int ny = upper_bound(coords[nx].begin(), coords[nx].end(), y) -
                    coords[nx].begin() - 1;
           ny >= 0; ny &= ny + 1, --ny) {
        ret += vals[nx][ny];
      }
    }
    return ret;
  }

  int get_leq(int lx, int rx, int y) { return get(rx, y) - get(lx - 1, y); }

  int get_geq(int lx, int rx, int y) {
    return (rx - lx + 1) - get_leq(lx, rx, y - 1);
  }
};

struct Fenwick {
  vector<int> fen;
  int n;
  Fenwick(int n) : n(n) { fen.resize(n); }
  void modify(int i, int x) {
    for (; i < n; i |= i + 1) {
      fen[i] += x;
    }
  }
  int get(int r) {
    int res = 0;
    for (; r >= 0; r &= r + 1, --r) {
      res += fen[r];
    }
    return res;
  }
};

int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(0);
  int t;
  cin >> t;
  while (t--) {
    int n;
    cin >> n;
    vector<int> a(n);
    for (int i = 0; i < n; ++i) {
      cin >> a[i];
      --a[i];
    }
    vector<ll> p(n);
    for (int i = 0; i < n; ++i) {
      cin >> p[i];
    }
    Fenwick seg_inv(n);

    auto calc = [&](int l, int r) {
      ll inv = 0;
      for (int i = r; i >= l; --i) {
        inv += seg_inv.get(a[i] - 1);
        seg_inv.modify(a[i], 1);
      }
      for (int i = l; i <= r; ++i) {
        seg_inv.modify(a[i], -1);
      }
      return inv;
    };

    vector<ll> seg_ans(n);
    seg_ans[0] = calc(0, n - 1);

    multiset<ll> all_ans;
    all_ans.insert(seg_ans[0]);

    set<int> dead;
    dead.insert(-1);
    dead.insert(n);

    Fenwick2d seg_count(n);

    for (int i = 0; i < n; ++i) {
      seg_count.fake_add(i, a[i]);
    }
    seg_count.compress();

    for (int i = 0; i < n; ++i) {
      seg_count.add(i, a[i]);
    }

    for (int i = 0; i < n; ++i) {
      ll ans = *all_ans.rbegin();
      cout << ans << ' ';
      /*cout << "!!!!! " << ans << endl;
      for (int i = 0; i < n; ++i) {
        cout << seg_ans[i] << ' ';
      }
      cout << endl;*/
      ll lind = (p[i] ^ ans) - 1;
      assert(0 <= lind && lind < n);
      int ind = (int)lind;
      assert(!dead.count(ind));
      auto it = dead.upper_bound(ind);
      // cout << "mem1" << endl;
      int r = (*it) - 1;
      int l = (*prev(it)) + 1;
      // cout << "mem2" << endl;
      dead.insert(ind);
      all_ans.erase(all_ans.find(seg_ans[l]));
      ll old_ans = seg_ans[l];
      seg_ans[l] = 0;
      // cout << "here" << endl;
      if (ind - l < r - ind) {
        // cout << "start1" << endl;
        if (l <= ind - 1) {
          seg_ans[l] = calc(l, ind - 1);
          all_ans.insert(seg_ans[l]);
        }
        if (ind + 1 <= r) {
          for (int j = l; j <= ind; ++j) {
            old_ans -= seg_count.get_leq(j + 1, r, a[j] - 1);
          }
          seg_ans[ind + 1] = old_ans;
          all_ans.insert(seg_ans[ind + 1]);
        }
        // cout << "finish1" << endl;
      } else {
        // cout << "start2" << endl;
        if (ind + 1 <= r) {
          seg_ans[ind + 1] = calc(ind + 1, r);
          all_ans.insert(seg_ans[ind + 1]);
        }
        if (l <= ind - 1) {
          for (int j = r; j >= ind; --j) {
            old_ans -= seg_count.get_geq(l, j - 1, a[j] + 1);
          }
          seg_ans[l] = old_ans;
          all_ans.insert(seg_ans[l]);
        }
        // cout << "finish2" << endl;
      }
    }
    cout << '\n';
  }
}