#include <bits/stdc++.h>

using namespace std;

#ifdef LOCAL
#include "../../debug.h"
#else
#define dbg(...) 787788
#endif

struct Fenwick {
    vector<int> a;

    Fenwick(int n) {
        a.resize(n);
    }

    Fenwick() = default;

    int sum(int pos) {
        int r = 0;
        while (pos >= 0) {
            r += a[pos];
            pos = (pos & (pos + 1)) - 1;
        }
        return r;
    }

    void inc(int pos, int val) {
        while (pos < (int)a.size()) {
            a[pos] += val;
            pos |= pos + 1;
        }
    }
};

struct Solver {
    vector<int> sorted;
    vector<int> vals;
    int fr, to;
    long long inv{};
    Fenwick f;

    Solver(vector<int> vals_) : vals(vals_) {
        sorted = vals;
        sort(sorted.begin(), sorted.end());
        sorted.erase(unique(sorted.begin(), sorted.end()), sorted.end());
        f = Fenwick(sorted.size());
        fr = 0;
        to = vals.size() - 1;
        for (int i = 0; i < (int)vals.size(); i++) {
            int pos = lower_bound(sorted.begin(), sorted.end(), vals[i]) - sorted.begin();
            inv += i - f.sum(pos);
            f.inc(pos, 1);
        }
    }

    void inc_fr() {
        int pos = lower_bound(sorted.begin(), sorted.end(), vals[fr]) - sorted.begin();
        inv -= f.sum(pos - 1);
        f.inc(pos, -1);
        fr++;
    }

    void dec_to() {
        int pos = lower_bound(sorted.begin(), sorted.end(), vals[to]) - sorted.begin();
        int tot = to - fr + 1;
        inv -= tot - f.sum(pos);
        f.inc(pos, -1);
        to--;
    }
};

void solve() {
    int tc;
    cin >> tc;
    for (int t = 0; t < tc; t++) {
        int n;
        cin >> n;
        vector<int> a(n);
        for (int i = 0; i < n; i++) {
            cin >> a[i];
        }
        vector<Solver> solvers;
        vector<int> solver_ids(n, -1);
        Solver base(a);
        multiset<long long> all_inv;
        all_inv.insert(base.inv);
        solvers.push_back(std::move(base));
        solver_ids[0] = 0;
        set<int> solvers_pos;
        solvers_pos.insert(0);
        solvers_pos.insert(n);
        for (int i = 0; i < n; i++) {
            long long mid_p;
            cin >> mid_p;
            long long max_inv = *all_inv.rbegin();
            cout << max_inv;
            if (i + 1 < n) {
                cout << ' ';
            } else {
                cout << '\n';
            }
            mid_p ^= max_inv;
            mid_p -= 1;

            assert(mid_p >= 0);
            assert(mid_p < n);
            auto it = solvers_pos.upper_bound(mid_p);
            it--;
            int pos = *it;
            int id = solver_ids[pos];
            assert(id != -1);
            int len = solvers[id].to - solvers[id].fr + 1;

            all_inv.erase(all_inv.find(solvers[id].inv));

            int next_pos = pos + len;
            int left = mid_p - pos;
            int right = len - left - 1;

            if (left > right) {
                if (right > 0) {
                    vector<int> new_group(a.begin() + mid_p + 1, a.begin() + next_pos);
                    Solver new_solver(std::move(new_group));
                    all_inv.insert(new_solver.inv);
                    solvers.push_back(std::move(new_solver));
                    int new_id = solvers.size() - 1;
                    solver_ids[mid_p + 1] = new_id;
                    solvers_pos.insert(mid_p + 1);
                }
                if (left > 0) {
                    for (int ii = 0; ii < right + 1; ii++) {
                        solvers[id].dec_to();
                    }
                    all_inv.insert(solvers[id].inv);
                }
            } else {
                if (left > 0) {
                    vector<int> new_group(a.begin() + pos, a.begin() + mid_p);
                    Solver new_solver(new_group);
                    all_inv.insert(new_solver.inv);
                    solvers.push_back(std::move(new_solver));
                    int new_id = solvers.size() - 1;
                    solver_ids[pos] = new_id;
                }
                if (right > 0) {
                    for (int ii = 0; ii < left + 1; ii++) {
                        solvers[id].inc_fr();
                    }
                    all_inv.insert(solvers[id].inv);
                    solver_ids[mid_p + 1] = id;
                    solvers_pos.insert(mid_p + 1);
                }
            }
        }
    }
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(0);

#ifdef LOCAL
    run_all_tests(solve);
    // run_single_test(solve, 1);
    // solve();
#else
    solve();
#endif
}