#include<stdio.h>

#include<string.h>

#include<stdlib.h>

int cmp(const void * x, const void * y) {

    //x < y

    return (*((int *)(x))) > (*((int *)(y))) ?  : -;

}

int a[], b[];

const int r[] = { , , , -, -, , , -, ,  };

int main(){

#ifndef ONLINE_JUDGE

    freopen("input.txt", "r", stdin);

#endif

    int n, d, x, y;

    scanf("%d", &n);

    for (int i = ; i <= n; i++){

        x = i, d = ;

        if (x %  == ) continue;

        bool flag = true;

        while (x){

            a[d++] = x % ;

            x /= ;

        }

        for (int j = ; j < d; j++){

            b[j] = r[a[d - j - ]];

            if (b[j] == -) flag = false;

        }

        y = ;

        for (int j = d - ; j >= ; j--){

            y = y *  + b[j];

        }

        if (y>n || y == i) flag = false;

        if (flag) printf("%d\n", i);

    }

    return ;

}

#include<stdio.h>

#include<string.h>

#include<stdlib.h>

int cmp(const void * x, const void * y) {

    //x < y

    return (*((int *)(x))) > (*((int *)(y))) ?  : -;

}

#include <vector>

#include <queue>

using namespace std;

vector<int> G[];

queue<int> q;

bool inq[], v[];

int d[];

int main(){

#ifndef ONLINE_JUDGE

    freopen("input.txt", "r", stdin);

#endif

    int n, m, a, b, ans;

    scanf("%d%d", &n, &m);

    for (int i = ; i <= n; i++){

        G[i].clear();

        d[i] = 0x3FFFFFFF;

    }

    d[] = ;

    memset(v, false, sizeof(v));

    for (int i = ; i < m; i++){

        scanf("%d%d", &a, &b);

        G[a].push_back(b);

        if (b == ) v[a] = true;

    }

    memset(inq, false, sizeof(inq));

    while (!q.empty()) q.pop();

    q.push();

    inq[] = true;

    while (!q.empty()){

        int x = q.front();

        q.pop();

        inq[x] = false;

        for (int i = ; i < G[x].size(); i++){

            int u = G[x][i];

            if (d[u]>d[x] + ){

                d[u] = d[x] + ;

                if (!inq[u]){

                    inq[u] = true;

                    q.push(u);

                }

            }

        }

    }

    ans = 0x3FFFFFFF;

    for (int i = ; i <= n; i++){

        if (v[i] && d[i] < ans) ans = d[i];

    }

    printf("%d\n", ans + );

    return ;

}

#include<stdio.h>

#include<string.h>

#include<stdlib.h>

int cmp(const void * x, const void * y) {

    //x < y

    return (*((double *)(x))) > (*((double *)(y))) ?  : -;

}

class MaxFlow_SAP {

public:

#define SAP_MAXN 20010

#define SAP_MAXM 880010

#define SAP_INF 0x3FFFFFFF

    struct Node {

        int from, to, next;

        int cap;

    } edge[SAP_MAXM];

    int tol;

    int head[SAP_MAXN];

    int dep[SAP_MAXN];

    int gap[SAP_MAXN];

    int cur[SAP_MAXN];

    int S[SAP_MAXN];

    int que[SAP_MAXN];

    int n;

    MaxFlow_SAP() {

        clear();

    }

    void clear() {

        tol = ;

        memset(head, -, sizeof(head));

    }

    void addedge(int u, int v, int w) {

        edge[tol].from = u;

        edge[tol].to = v;

        edge[tol].cap = w;

        edge[tol].next = head[u];

        head[u] = tol++;

        edge[tol].from = v;

        edge[tol].to = u;

        edge[tol].cap = ;

        edge[tol].next = head[v];

        head[v] = tol++;

    }

    void BFS(int start, int end) {

        memset(dep, -, sizeof(dep));

        memset(gap, , sizeof(gap));

        gap[] = ;

        int front, rear;

        front = rear = ;

        dep[end] = ;

        que[rear++] = end;

        while (front != rear) {

            int u = que[front++];

            if (front == SAP_MAXN) {

                front = ;

            }

            for (int i = head[u]; i != -; i = edge[i].next) {

                int v = edge[i].to;

                if (dep[v] != -) {

                    continue;

                }

                que[rear++] = v;

                if (rear == SAP_MAXN) {

                    rear = ;

                }

                dep[v] = dep[u] + ;

                ++gap[dep[v]];

            }

        }

    }

    int SAP(int start, int end) {

        int res = ;

        BFS(start, end);

        int top = ;

        memcpy(cur, head, sizeof(head));

        int u = start;

        int i;

        while (dep[start] < n) {

            if (u == end) {

                int temp = SAP_INF;

                int inser;

                for (i = ; i < top; i++)

                    if (temp > edge[S[i]].cap) {

                        temp = edge[S[i]].cap;

                        inser = i;

                    }

                for (i = ; i < top; i++) {

                    edge[S[i]].cap -= temp;

                    edge[S[i] ^ ].cap += temp;

                }

                res += temp;

                top = inser;

                u = edge[S[top]].from;

            }

            if (u != end && gap[dep[u] - ] == ) {

                break;

            }

            for (i = cur[u]; i != -; i = edge[i].next)

                if (edge[i].cap !=  && dep[u] == dep[edge[i].to] + ) {

                    break;

                }

            if (i != -) {

                cur[u] = i;

                S[top++] = i;

                u = edge[i].to;

            } else {

                int min = n;

                for (i = head[u]; i != -; i = edge[i].next) {

                    if (edge[i].cap == ) {

                        continue;

                    }

                    if (min > dep[edge[i].to]) {

                        min = dep[edge[i].to];

                        cur[u] = i;

                    }

                }

                --gap[dep[u]];

                dep[u] = min + ;

                ++gap[dep[u]];

                if (u != start) {

                    u = edge[S[--top]].from;

                }

            }

        }

        return res;

    }

};

char str[], dict[][];

MaxFlow_SAP sap;

int main() {

#ifndef ONLINE_JUDGE

    freopen("input.txt", "r", stdin);

#endif

    int n, s, t;

    scanf("%d", &t);

    while (t--) {

        scanf("%d", &n);

        scanf("%s", str);

        s = strlen(str);

        for (int i = ; i < n; i++) {

            scanf("%s", dict[i]);

        }

        sap.clear(), sap.n = n + s + ;

        for (int i = ; i <= n + ; i++) {

            sap.addedge(, i, );

        }

        for (int i = n + ; i <= n + s + ; i++) {

            sap.addedge(i, n + s + , );

        }

        for (int i = ; i < n; i++) {

            int m = strlen(dict[i]);

            for (int j = ; j < m; j++) {

                for (int k = ; k < s; k++) {

                    if (dict[i][j] == str[k]) {

                        sap.addedge(i + , n  + k + , );

                    }

                }

            }

        }

        int maxflow = sap.SAP(, n + s + );

        if (maxflow == s) printf("Yes\n");

        else printf("No\n");

        //1 2~n+1 n+2~n+s+1 n+s+2

    }

    return ;

}