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

#ifdef CKISEKI
#define safe cerr << __PRETTY_FUNCTION__ << " line " << __LINE__ << " safe\n"
#define debug(a...) debug_(#a, a)
#define orange(a...) orange_(#a, a)
template <typename ...T>
void debug_(const char *s, T ...a) {
    cerr << "\e[1;32m(" << s << ") = (";
    int cnt = sizeof...(T);
    (..., (cerr << a << (--cnt ? ", " : ")\e[0m\n")));
}
template <typename I>
void orange_(const char *s, I L, I R) {
    cerr << "\e[1;32m[ " << s << " ] = [ ";
    for (int f = 0; L != R; ++L)
        cerr << (f++ ? ", " : "") << *L;
    cerr << " ]\e[0m\n";
}
#else
#define safe ((void)0)
#define debug(...) safe
#define orange(...) safe
#endif
#define all(v) begin(v),end(v)

using namespace std;
using VI = vector<int>;

const int C = 10;
const int S = 512;
const int M = 317;

mt19937 rng(1238009);

using lld = int64_t;

lld fac[20] = {};
lld getNum(vector<int> p, int n) {
    if (n == 1)
        return 0;

    for (int i = 0; i < n; i++)
        if (p[i] == n-1) {
            swap(p[i], p[n-1]);
            return i * fac[n-1] + getNum(p, n - 1);
        }
    __builtin_unreachable();
}

void restore(lld num, vector<int> &p, int n) {
    if (n == 1) {
        assert (num == 0);
        p[0] = 0;
        return;
    }
    debug(n, fac[n-1]);
    restore(num % fac[n-1], p, n-1);
    int i = num / fac[n-1];
    p[n-1] = n-1;
    swap(p[i], p[n-1]);
}

pair<VI, VI> genPerm(int x, int k1, int k2) {
    VI p1(C);
    VI p2(C);
    // iota(all(p1), 0);
    // iota(all(p2), 0);
    // shuffle(all(p1), rng);
    // shuffle(all(p2), rng);

    restore(x + S * M * k1, p1, C);
    restore(x + S * M * k2, p2, C);
    debug(getNum(p1, C), x + S * M * k1);
    debug(getNum(p2, C), x + S * M * k2);
    return { p1, p2 };
}

vector<int> recover(vector<int>);

vector<int> transmit(vector<int> a) {
    int n = a.size();
    int xo = 0;
    for (int x: a) xo ^= x;

    sort(a.begin(), a.end());
    for (int k1 = 0; k1 < 20; k1++) {
        for (int k2 = 0; k2 < 20; k2++) {
            auto [p1, p2] = genPerm(xo, k1, k2);
            orange(all(p1));
            orange(all(p2));

            auto b = a;
            for (int i = 0; i < C; i++)
                b[i] = a[p1[i]];
            for (int i = 0; i < C; i++)
                b[n-C+i] = a[n-C+p2[i]];

            bool ok = (recover(b) == a);
            for (int i = 0; i < n && ok; i++) {
                auto tb = b;
                tb.erase(tb.begin() + i);
                if (recover(b) != a) {
                    ok = false;
                    break;
                }
            }
            if (ok)
                return b;
        }
    }

    __builtin_unreachable();
}

vector<int> recover(vector<int> b) {
    int m = b.size();
    vector<pair<int,int>> pr1, pr2;
    for (int i = 0; i < C; i++) {
        pr1.emplace_back(b[i], i);
    }
    for (int i = 0; i < C; i++) {
        pr2.emplace_back(b[m-C+i], i);
    }
    assert (pr1.size() == C && pr2.size() == C);
    vector<int> p1(C), p2(C);
    sort(pr1.begin(), pr1.end());
    sort(pr2.begin(), pr2.end());

    for (int i = 0; i < C; i++)
        p1[pr1[i].second] = i;
    for (int i = 0; i < C; i++)
        p2[pr2[i].second] = i;

    orange(all(p1));
    orange(all(p2));

    lld x1 = getNum(p1, C);
    lld x2 = getNum(p1, C);
    lld x = 0;
    if ((x1 / 512) % M == 0) {
        x = x1 % 512;
    } else if ((x2 / 512) % M == 0) {
        x = x2 % 512;
    }
    for (int z: b)
        x ^= z;
    if (x != 0) {
        b.push_back(x);
    }
    sort(b.begin(), b.end());

    return b;
}

void test() {
    VI a(500);
    iota(a.begin(), a.end(), 1);
    shuffle(a.begin(), a.end(), rng);
    a.resize(20);
    assert (set(a.begin(), a.end()).size() == a.size());
    assert (a.size() >= 20);
    auto b = transmit(a);
    recover(b);
}

int main() {
    fac[0] = 1;
    for (int i = 1; i <= 10; i++)
        fac[i] = fac[i - 1] * i;
    cin.tie(nullptr)->sync_with_stdio(false);

    // test();
    // return 0;

    string type;
    cin >> type;
    if (type == "transmit") {
        int T;
        cin >> T;
        while (T--) {
            int n;
            cin >> n;
            vector<int> a(n);
            for (int i = 0; i < n; i++)
                cin >> a[i];
            auto b = transmit(a);
            for (int i = 0; i < n; i++)
                cout << b[i] << (i+1==n ? '\n' : ' ');
        }
    } else if (type == "recover") {
        int T;
        cin >> T;
        while (T--) {
            int m;
            cin >> m;
            vector<int> b(m);
            for (int i = 0; i < m; i++)
                cin >> b[i];
            auto a = recover(b);
            int n = a.size();
            for (int i = 0; i < n; i++)
                cout << a[i] << (i+1==n ? '\n' : ' ');
        }
    }
    return 0;
}