// Solution is valid, but doesn't always run within the query limit

#include <iostream>
#include <vector>
#include <utility>
#include <algorithm>
#include <random>
#include <cassert>

//#define SELF_TEST 1

using namespace std;

#define SZ(x) (int((x).size()))
typedef vector<int> vi;
typedef pair<int, int> pii;
typedef vector<pii> vpii;

static int N;
static vi st;
static int nqueries = 0;
static vi permute;

static constexpr int MAX_QUERIES = 12;

#ifdef SELF_TEST
static vector<bool> working;
#endif

static vi query(const vpii &q)
{
    nqueries++;
    vi perm(N, -1);
#ifdef SELF_TEST
    set<int> seen[2];
#endif
    for (const auto &item : q)
    {
        perm[permute[item.first]] = permute[item.second];
#ifdef SELF_TEST
        assert(!seen[0].count(item.first));
        assert(!seen[1].count(item.second));
        seen[0].insert(item.first);
        seen[1].insert(item.second);
#endif
    }

    string line;
#ifdef SELF_TEST
    for (int i = 0; i < N; i++)
    {
        if (working[i])
            line += working[perm[i]] ? '1' : '0';
        else
            line += '1';
    }
#else
    cout << "test";
    for (int i = 0; i < N; i++)
        cout << ' ' << perm[i] + 1;
    cout << endl;
    cin >> line;
#endif
    vi ans;
    for (const auto &item : q)
        ans.push_back(line[permute[item.first]] == '1');
    return ans;
}

static void solve(const vi &cand)
{
    int M = cand.size();
    vpii q;
    vi ans;

    if (M <= 2)
    {
        for (int v : cand)
            st[v] = 1;
    }
    else if (M == 3)
    {
        q.emplace_back(cand[0], cand[1]);
        q.emplace_back(cand[1], cand[2]);
        q.emplace_back(cand[2], cand[0]);
        ans = query(q);
        st[cand[0]] = st[cand[1]] = st[cand[2]] = 1;
        for (int i = 0; i < 3; i++)
            if (ans[i] == 1 && ans[(i + 1) % 3] == 0)
                st[cand[(i + 2) % 3]] = 0;
    }
    else
    {
        for (int i = 0; i + 1 < M; i += 2)
        {
            q.emplace_back(cand[i], cand[i + 1]);
            q.emplace_back(cand[i + 1], cand[i]);
        }
        ans = query(q);
        vi sub, dup, other;
        for (int i = 0; i + 1 < M; i += 2)
        {
            if (ans[i] == 1 && ans[i + 1] == 1)
            {
                sub.push_back(cand[i]);
                dup.push_back(cand[i + 1]);
            }
            else
            {
                other.push_back(cand[i]);
                other.push_back(cand[i + 1]);
            }
        }
        if (M & 1)
        {
            if (SZ(sub) % 2 == 0)
                sub.push_back(cand.back());
            else
                other.push_back(cand.back());
        }
        solve(sub);
        for (int i = 0; i < SZ(dup); i++)
            st[dup[i]] = st[sub[i]];
        vi good;
        int known = 0;
        for (int i = 0; i < M; i++)
        {
            if (st[cand[i]] != -1)
                known++;
            if (st[cand[i]] == 1)
                good.push_back(cand[i]);
        }
        while (!other.empty())
        {
            if (2 * (SZ(good) + SZ(other) / 2) <= M)
            {
                st[other.back()] = 1;
                good.push_back(other.back());
                other.pop_back();
                known++;
            }
            else
            {
                q.clear();
                for (int v : good)
                {
                    if (other.empty())
                        break;
                    q.emplace_back(v, other.back());
                    other.pop_back();
                }
                ans = query(q);
                for (int i = 0; i < SZ(q); i++)
                {
                    known++;
                    st[q[i].second] = ans[i];
                    if (ans[i])
                        good.push_back(q[i].second);
                }
            }
        }
    }
}

int main()
{
    mt19937 engine(2645644534);
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    int T;
    cin >> T;
    for (int cas = 0; cas < T; cas++)
    {
        cin >> N;
        nqueries = 0;
#ifdef SELF_TEST
        string line;
        cin >> line;
        assert(SZ(line) == N);
        working.resize(N);
        for (int i = 0; i < N; i++)
            working[i] = (line[i] == '1');
        assert(count(working.begin(), working.end(), 1) * 2 > N);
#endif

        permute.clear();
        for (int i = 0; i < N; i++)
            permute.push_back(i);
        shuffle(permute.begin(), permute.end(), engine);
        st.clear();
        st.resize(N, -1);
        vi cand;
        for (int i = 0; i < N; i++)
            cand.push_back(i);
        solve(cand);

        string ans(N, '?');
        for (int i = 0; i < N; i++)
        {
            assert(st[i] != -1);
            ans[permute[i]] = char(st[i]) + '0';
        }
#ifdef SELF_TEST
        assert(ans == working);
        cout << nqueries << " queries\n";
        assert(nqueries <= MAX_QUERIES);
#else
        cout << "answer " << ans << endl;
#endif
    }
    return 0;
}