#include <bits/stdc++.h>
using namespace std;

#include <bits/extc++.h>
using namespace __gnu_pbds;
template <typename T>
using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;

using i64 = long long;

int main() {
    cin.tie(nullptr)->sync_with_stdio(false);

    int t;
    cin >> t;

    auto solve = [&]() {
        int n;
        cin >> n;

        vector<int> a(n);
        for (int i = 0; i < n; i++) {
            cin >> a[i];
        }

        vector<pair<int, int>> segs{{0, n - 1}};
        vector<int> id(n, 0);
        vector<i64> inv(1);
        multiset<i64> vals;
        vector<ordered_set<pair<int, int>>> s(1);

        for (int i = 0; i < n; i++) {
            inv[0] += s[0].size() - s[0].order_of_key(pair(a[i], n));
            s[0].insert(pair(a[i], i));
        }
        vals.emplace(inv[0]);

        i64 lst = 0;

        for (int rep = 0; rep < n; rep++) {
            cout << (lst = *vals.rbegin()) << " \n"[rep + 1 == n];
            i64 p;
            cin >> p;
            p ^= lst;
            assert(1 <= p && p <= n);
            p--;

            int cur = id[p];
            id[p] = -1;
            auto [l, r] = segs[cur];
            vals.extract(inv[cur]);
            int nxt = segs.size();
            inv.emplace_back();
            s.emplace_back();

            if (p - l < r - p) {
                segs[cur] = {p + 1, r};
                segs.emplace_back(p - 1, r);
                for (int i = l; i < p; i++) {
                    id[i] = nxt;
                }
                for (int i = l; i <= p; i++) {
                    s[cur].erase(pair(a[i], i));
                    inv[cur] -= s[cur].order_of_key(pair(a[i], -1));
                }
                for (int i = p - 1; i >= l; i--) {
                    inv[nxt] += s[nxt].order_of_key(pair(a[i], -1));
                    s[nxt].insert(pair(a[i], i));
                }
            } else {
                segs[cur] = {l, p - 1};
                segs.emplace_back(p + 1, r);
                for (int i = p + 1; i <= r; i++) {
                    id[i] = nxt;
                }
                for (int i = r; i >= p; i--) {
                    s[cur].erase(pair(a[i], i));
                    inv[cur] -= s[cur].size() - s[cur].order_of_key(pair(a[i], n));
                }
                for (int i = p + 1; i <= r; i++) {
                    inv[nxt] += s[nxt].size() - s[nxt].order_of_key(pair(a[i], n));
                    s[nxt].insert(pair(a[i], i));
                }
            }

            vals.insert(inv[cur]);
            vals.insert(inv[nxt]);

            assert(inv.size() == segs.size() && segs.size() == s.size() && vals.size() == s.size());
        }
    };
    
    while (t--) {
        solve();
    }
    
    return 0;
}