#include <bits/stdc++.h>

using namespace std;

#define ll long long
#define REP1(i, n) for(ll i = 0; i < (n); i++)
#define REP2(i, a, b) for(ll i = (a); i < (b); i++)
#define REP0(n) for(ll iii = 0; iii < (n); iii++)
#define overload3(a, b, c, name, ...) name
#define rep(...) overload3(__VA_ARGS__, REP2, REP1, REP0)(__VA_ARGS__)
#define si(c) (ll)(c.size())
#define pll pair<ll, ll>

#define vl vector<ll>
#define all(v) v.begin(), v.end()
#define fore(e, v) for(auto &&e : v)

template <typename T, typename S> bool chmax(T &x, const S &y) { return (x < y ? x = y, true : false); }
template <typename T, typename S> bool chmin(T &x, const S &y) { return (x > y ? x = y, true : false); }

template <typename T> ostream &operator<<(ostream &os, const vector<T> &v) {
    os << "{";
    rep(i, si(v)) {
        if(i) os << ", ";
        os << v[i];
    }
    return os << "}";
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0), cout.tie(0);
    int t;
    cin >> t;
    while(t--) {
        ll n, x, y, z;
        cin >> n >> x >> y >> z;

        vector<ll> c(n);
        fore(e, c) cin >> e;

        ll k = 0;
        vl v(n);
        fore(e, c) v[e]++;
        rep(i, n) k += (!!v[i]);

        string op;
        rep(x) op.push_back('&');
        rep(z) op.push_back('^');
        rep(y) op.push_back('|');

        vl ans;
        if(k == 1 or (x == n) or (y == n) or (z == n)) {
            rep(i, n) ans.emplace_back(c[i]);
        } else if(y + z <= k) {
            for(ll i = n - 1; i >= 0; i--) {
                if(v[i]) { ans.emplace_back(i); }
            }
            for(ll i = n - 1; i >= 0; i--) {
                if(v[i]) rep(v[i] - 1) ans.emplace_back(i);
            }
            reverse(all(ans));
        } else if(!x) {
            int E = 0;
            rep(i, n) if(~v[i] & 1) E++;
            vl lst;
            for(ll i = n - 1; i >= 0; i--) {
                if(y and ~v[i] & 1 and v[i]) {
                    lst.emplace_back(i), v[i]--;
                    y--;
                }
            }
            rep(i, n) rep(v[i]) ans.emplace_back(i);
            fore(e, lst) ans.emplace_back(e);
        } else {
            int E = 0;
            rep(i, n) if(v[i] and ~v[i] & 1) E++;
            vl lst;
            if(x + y <= E) {
                for(ll i = n - 1; i >= 0; i--) {
                    if(ans.size() < (E - x - y) and v[i] and ~v[i] & 1) {
                        ans.emplace_back(i);
                        v[i]--;
                    }
                }
                rep(i, E - x - y) {
                    op[i] = '^';
                    op[x + i] = '&';
                }
                for(ll i = n - 1; i >= 0; i--) {
                    if(ans.size() < E - y and v[i] and ~v[i] & 1) {
                        ans.emplace_back(i);
                        v[i]--;
                    }
                }
                for(ll i = n - 1; i >= 0; i--) {
                    if(lst.size() < y and v[i] and ~v[i] & 1) {
                        lst.emplace_back(i);
                        v[i]--;
                    }
                }
                rep(i, n) rep(v[i]) ans.emplace_back(i);
                fore(e, lst) ans.emplace_back(e);
            } else {
                if(!y) {
                    if(x == 1) {
                        // cout << "here" << endl;

                        rep(i, n) {
                            if(v[i]) {
                                v[i]--;
                                x--;
                                ans.emplace_back(i);
                                break;
                            }
                        }
                        rep(i, n) rep(v[i]) ans.emplace_back(i);
                    } else if((E ^ x) & 1) {
                        swap(op[x], op[0]);
                        x++, z--;

                        int cnt = 0; // 2 個以上
                        rep(i, n) cnt += (v[i] > 1);
                        if(cnt >= 2) {
                            vl used(n);
                            for(ll i = n - 1; i >= 0; i--) {
                                if(v[i] and ~v[i] & 1) ans.emplace_back(i), v[i]--, x--, used[i] = true;
                            }
                            rep(i, n) if(!used[i]) {
                                if(x >= 2 and v[i] >= 2) {
                                    v[i] -= 2, x -= 2;
                                    rep(2) ans.emplace_back(i);
                                }
                            }
                            rep(i, n) while(x >= 2 and v[i] >= 2) {
                                v[i] -= 2, x -= 2;
                                rep(2) ans.emplace_back(i);
                            }
                            rep(i, n) rep(v[i]) ans.emplace_back(i);
                        } else {
                            // cout << "here" << endl;
                            x--;
                            z++;
                            swap(op[x], op[0]);
                            int k = 0;
                            rep(i, n) {
                                if(v[i]) {
                                    k = i;
                                    break;
                                }
                            }

                            if(v[k] > 1) {
                                assert(v[k] >= x);
                                rep(i, x) v[k]--, ans.emplace_back(k), x--;
                                rep(i, n) rep(v[i]) ans.emplace_back(i);
                            } else {
                                ans.emplace_back(k);
                                v[k]--;
                                x--;
                                for(ll i = n - 1; i >= 0; i--) {
                                    if(v[i] and ~v[i] & 1) v[i]--, ans.emplace_back(i), x--;
                                }
                                rep(i, n) while(x >= 2 and v[i] >= 2) {
                                    rep(2) ans.emplace_back(i);
                                    x -= 2, v[i] -= 2;
                                }
                                rep(i, n) rep(v[i]) ans.emplace_back(i);
                            }
                        }
                    } else {
                        for(ll i = n - 1; i >= 0; i--) {
                            if(v[i] and ~v[i] & 1) ans.emplace_back(i), v[i]--, x--;
                        }
                        rep(i, n) {
                            while(v[i] >= 2 and x >= 2) {
                                v[i] -= 2, x -= 2;
                                rep(2) ans.emplace_back(i);
                            }
                        }
                        rep(i, n) rep(v[i]) ans.emplace_back(i);
                    }

                } else {
                    vl lst;
                    for(ll i = n - 1; i >= 0; i--) {
                        if(v[i] and ~v[i] & 1) {
                            ans.emplace_back(i), v[i]--, x--;
                            if(!x) break;
                        }
                    }
                    if(!x) {
                        rep(i, n) {
                            if(v[i] and ~v[i] & 1) { lst.emplace_back(i), v[i]--, y--; }
                        }
                    } else {
                        rep(i, n) {
                            while(v[i] >= 2 and x) {
                                if(x == 1) {
                                    ans.emplace_back(i);
                                    lst.emplace_back(i);
                                    x--, y--;
                                } else {
                                    rep(2) ans.emplace_back(i);
                                    x -= 2;
                                }
                                v[i] -= 2;
                            }
                        }
                        assert(x == 0);
                    }
                    rep(i, n) rep(v[i]) ans.emplace_back(i);
                    fore(e, lst) ans.emplace_back(e);
                }
            }
        }

        map<ll, ll> mp;
        rep(i, n) {
            if(op[i] == '&') {
                if(mp[ans[i]]) {
                    mp = map<ll, ll>();
                    mp[ans[i]] = 1;
                } else {
                    mp = map<ll, ll>();
                }
            }
            if(op[i] == '^') mp[ans[i]] ^= 1;
            if(op[i] == '|') mp[ans[i]] |= 1;
        }

        // {
        //     auto C = c;
        //     sort(all(C));
        //     auto D = ans;
        //     sort(all(D));
        //     assert(C == D);
        // }

        rep(i, n) cout << mp[n - 1 - i];
        cout << endl;
        cout << op << endl;
        rep(i, n) cout << ans[i] << " \n"[i == n - 1];
    }
}