#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <ctime>
#include <cassert>
#include <memory.h>

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <set>
#include <map>
#include <queue>
#include <deque>
#include <list>
#include <complex>

using namespace std;

#define INF 1000000001
#define INFL 1000000000000000001ll
#define pb push_back
#define fi first
#define se second
#define mp make_pair
#define sz(x) ((int) (x).size())

typedef long long ll;
typedef long double ld;
typedef complex <ld> point;

#define NAME "guess"

map <pair <string, vector <char> >, char> ans;
int n, len;
vector <string> str[10];
char buf[10];
char sym[10001];
int alpha;

inline void clear() {
    ans.clear();
    alpha = 0;
    for (int i = 1; i <= 6; ++i)
        str[i].clear();
}

inline char empty_set(string &s, vector <char> &bad) {
    for (int i = 0; i < (int) str[len].size(); ++i) {
        char ok = 1;
        for (int j = 0; j < len; ++j)
            if (s[j] != '*' && s[j] != str[len][i][j])
                ok = 0, j = 1000;
        if (!ok)
            continue;
        for (int j = 0; j < len; ++j)
            for (int k = 0; k < (int) bad.size(); ++k)
                if (bad[k] == str[len][i][j])
                    ok = 0, j = 1000, k = 1000;
        if (!ok)
            continue;
        return 0;
    }
    return 1;
}

inline void v_insert(vector <char> &v, char sym) {
    int pos = v.size();
    v.pb(sym);
    while (pos > 0 && v[pos - 1] > v[pos])
        swap(v[pos - 1], v[pos]), --pos;
}

inline void v_erase(vector <char> &v, char sym) {
    for (int i = 0; i < (int) v.size(); ++i)
        if (v[i] == sym) {
            for (int j = i + 1; j < (int) v.size(); ++j)
                v[j - 1] = v[j];
            v.pop_back();
            return;
        }
}

inline char guessed(string &s) {
    for (int i = 0; i < len; ++i)
        if (s[i] == '*')
            return 0;
    return 1;
}

inline char calc(string &s, vector <char> &bad) {
    //~ cerr << s << ' ';
    //~ for (int i = 0; i < (int) bad.size(); ++i)
        //~ cerr << bad[i];
    //~ cerr << '\n';
    if (ans.count(mp(s, bad)))
        return ans[mp(s, bad)];
    if (empty_set(s, bad))
        return ans[mp(s, bad)] = 0;
    if ((int) bad.size() > len)
        return ans[mp(s, bad)] = 1;
    if (guessed(s))
        return ans[mp(s, bad)] = 0;
    for (int i = 0; i < alpha; ++i) {
        char ok = 1;
        for (int j = 0; j < (int) bad.size(); ++j)
            if (bad[j] == sym[i])
                ok = 0, j = 1000;
        for (int j = 0; j < len; ++j)
            if (s[j] == sym[i])
                ok = 0, j = 1000;
        if (!ok)
            continue;
        v_insert(bad, sym[i]);
        if (calc(s, bad)) {
            v_erase(bad, sym[i]);
            continue;
        }
        v_erase(bad, sym[i]);
        for (int j = 0; j < len; ++j) {
            if (s[j] != '*')
                continue;
            s[j] = sym[i];
            if (calc(s, bad)) {
                ok = 0;
                s[j] = '*';
                break;
            }
            s[j] = '*';
        }
        if (!ok)
            continue;
        return ans[mp(s, bad)] = 0;
    }
    return ans[mp(s, bad)] = 1;
}

inline void solve() {
    scanf("%d", &n);
    for (int i = 0; i < n; ++i) {
        scanf("%s", buf);
        str[strlen(buf)].pb(buf);
        for (int j = 0; buf[j]; ++j)
            sym[alpha++] = buf[j];
    }
    sort(sym, sym + alpha);
    alpha = unique(sym, sym + alpha) - sym;
    //~ cerr << alpha << '\n';
    string empty = "";
    vector <char> empty_bad(0);
    for (len = 1; len < 7; ++len) {
        empty += '*';
        assert(empty_bad.empty());
        if (calc(empty, empty_bad)) {
            cout << "Yes\n";
            clear();
            return;
        }
    }
    cout << "No\n";
    clear();
}

int main() {
    srand(time(0));
    cout.setf(ios::fixed);
    cout.precision(10);
    #ifdef _GEANY
    assert(freopen(NAME ".in", "r", stdin));
    #endif
    int tn;
    cin >> tn;
    for (int i = 0; i < tn; ++i)
        solve();
}