#include <cstdio>
#include <algorithm>
#include <vector>
#include <cstring>
#include <queue>
#include <map>
#include <unordered_map>
#pragma GCC optimize(3)

using namespace std;

const int max1 = 15, max2 = 1 << 15;
const int max3 = 32;
const long long max4 = 1LL << 32;
const int inf = 0x3f3f3f3f;

int T, n, len;
char s[max2 + 5], ans[max2 + 5];
bool vis[max2 + 5];

struct Data
{
    char c;
    long long son[2];
    int len;
};

unordered_map <long long, Data> d;
long long seq[max2 + 5];
int cnt;

struct Node
{
    long long now;
    int d;

    Node () {}
    Node ( long long __now, int __d )
        { now = __now, d = __d; }
    
    bool operator < ( const Node &A ) const
    {
        return d > A.d;
    }
};

priority_queue <Node> que;

void Print ( long long now )
{
    // printf("hahahah\n");

    if ( !d[now].len )
        { ans[++len] = d[now].c; return; }
    
    ans[++len] = '(';
    Print(d[now].son[0]);
    ans[++len] = d[now].c;
    Print(d[now].son[1]);
    ans[++len] = ')';
    return;
}

bool Dfs ( int now, int L, int R )
{
    int cnt0 = 0, cnt1 = 0;
    for ( int i = L; i <= R; i ++ )
    {
        cnt0 += s[i] == '0';
        cnt1 += s[i] == '1';
    }

    if ( cnt0 == R - L + 1 )
    {
        ans[++len] = 'F';
        return true;
    }
    if ( cnt1 == R - L + 1 )
    {
        ans[++len] = 'T';
        for ( int i = L; i <= R; i ++ )
            vis[i] = true;
        return true;
    }

    if ( now == 5 )
    {
        long long now = 0;
        for ( int i = R; i >= L; i -- )
            now = (now << 1) | (s[i] - '0');
        
        if ( d.find(now) == d.end() )
            return false;
        Print(now);
        return true;
    }

    if ( now == 1 )
    {
        if ( s[L] == '1' && s[R] == '0' )
            return false;
        
        ans[++len] = 'a' + now - 1;
        vis[R] = true;
        return true;
    }

    int mid = (L + R) >> 1, midlen = mid - L + 1;
    for ( int i = 0; i < midlen; i ++ )
        if ( s[L + i] == '1' && s[mid + 1 + i] == '0' )
            return false;
    
    ans[++len] = '(';
    if ( !Dfs(now - 1, L, mid) )
        return false;

    bool flag = ans[len] == 'F';
    if ( ans[len] == 'F' )
        len -= 2;
    else
        ans[++len] = '|';

    for ( int i = 0; i < midlen; i ++ )
    {
        if ( s[L + i] == '1' && s[mid + 1 + i] == '1' )
        {
            if ( vis[L + i] )
                vis[L + i] = vis[mid + 1 + i] = true;
        }
    }

    ans[++len] = '(';
    ans[++len] = 'a' + now - 1;
    ans[++len] = '&';
    if ( !Dfs(now - 1, mid + 1, R) )
        return false;
    
    if ( ans[len] == 'T' )
    {
        len -= 4;
        ans[++len] = 'a' + now - 1;
    }
    else
        ans[++len] = ')';
    if ( !flag )
        ans[++len] = ')';
    return true;
}

void Work ()
{
    scanf("%d%s", &n, s);
    memset(vis, 0, sizeof(bool) * (1 << n));
    len = 0;
    if ( Dfs(n, 0, (1 << n) - 1) )
    {
        printf("Yes\n");
        for ( int i = 1; i <= len; i ++ )
            putchar(ans[i]);
        putchar('\n');
        return;
    }
    else
    {
        printf("No\n");
    }
    return;
}

int main () 
{   
    d[0].c = 'T';
    d[0].len = 0;
    d[0].son[0] = d[0].son[1] = 0;
    que.push(Node(0, 0));
    d[max4 - 1].c = 'F';
    d[max4 - 1].len = 0;
    d[max4 - 1].son[0] = d[max4 - 1].son[1] = 0;
    que.push(Node(max4 - 1, 0));

    for ( int i = 1; i <= 5; i ++ )
    {
        long long p = 0;
        for ( int s = 0; s < max3; s ++ )
            if ( (s >> (i - 1)) & 1 )
                p |= 1LL << s;
        
        d[p].c = 'a' + i - 1;
        d[p].len = 0;
        d[p].son[0] = d[p].son[1] = 0;
        // printf("i = %d p = %d\n", i, p);
        que.push(Node(p, 0));
    }

    while ( !que.empty() )
    {
        long long now = que.top().now;
        int dis = que.top().d;
        que.pop();
        if ( dis > d[now].len )
            continue;
        
        // printf("now = %lld\n", now);
        
        for ( int i = 1; i <= cnt; i ++ )
        {
            long long v = seq[i] & now;

            if ( d.find(v) == d.end() || d[v].len > d[now].len + d[seq[i]].len + 1 )
            {
                d[v].c = '&';
                d[v].len = d[now].len + d[seq[i]].len + 1;
                d[v].son[0] = now;
                d[v].son[1] = seq[i];
                que.push(Node(v, d[v].len));
            }

            v = seq[i] | now;
            
            if ( d.find(v) == d.end() || d[v].len > d[now].len + d[seq[i]].len + 1 )
            {
                d[v].c = '|';
                d[v].len = d[now].len + d[seq[i]].len + 1;
                d[v].son[0] = now;
                d[v].son[1] = seq[i];
                que.push(Node(v, d[v].len));
            }
        }

        seq[++cnt] = now;
    }


    scanf("%d", &T);
    while ( T -- )
        Work();

    return 0;
}