#include <bits/stdc++.h>

using namespace std;

typedef vector <int> vi;

const int MAX_N = 130;
const int MAX_M = 1 << 21;
const int MAX_V = 1 << 15;
const int MAX_E = 1 << 17;
const int INF32 = 0x3f3f3f3f;

int N, s, t;
struct TrieNode{
    int son[52], dep, fa, col;
}node[MAX_M];
int tot, cur[MAX_N], cnt, idx[MAX_M], w[MAX_V], M;
struct Edge{
    int y, prev, cap, cost;
}e[MAX_E];
int elast[MAX_V], ecnt = 1;
int dis[MAX_V], pre[MAX_V], flow;
char inq[MAX_V], vis[MAX_M], mark[MAX_M];
string ans[MAX_N], pat[MAX_V];

void Build(int x, int y, int z, int c) {
    ecnt ++;
    e[ecnt].y = y;
    e[ecnt].cap = z;
    e[ecnt].cost = c;
    e[ecnt].prev = elast[x];
    elast[x] = ecnt;
}

void add_edge(int x, int y, int z, int c) {
    Build(x, y, z, c); Build(y, x, 0, -c);
}

bool spfa() {
	queue <int> q;
	memset(dis, 0x3f, sizeof(int) * (t + 1));
	q.push(s); dis[s] = 0;
	while (!q.empty()) {
		int u = q.front(); q.pop(); inq[u] = 0;
		for (int i = elast[u]; i; i = e[i].prev) {
			int v = e[i].y;
			if (e[i].cap && dis[u] + e[i].cost < dis[v]) {
                pre[v] = i;
				dis[v] = dis[u] + e[i].cost;
				if (!inq[v]) {
					inq[v] = 1; q.push(v);
				}
			}
		}
	}
    if (dis[t] >= INF32) return false;
    int f = N;
    for (int v = t; v != s; v = e[pre[v] ^ 1].y) f = min(f, e[pre[v]].cap);
    for (int v = t; v != s; v = e[pre[v] ^ 1].y) {
        e[pre[v]].cap -= f;
        e[pre[v] ^ 1].cap += f;
    }
    flow += f;
    return true;
}

vi ins(const vi &s, int u, const vi &a) {
    vi c(0);
    for (auto i = a.begin(), j = s.begin(); (int)c.size() < N; ) {
        while (i != a.end() && vis[*i]) i ++;
        if (i == a.end() && j == s.end()) break;
        if (j == s.end() || (i != a.end() && node[*i].dep <= node[u].dep + 1)) {
            c.push_back(*(i ++));
        }else {
            int col = *(j ++);
            int &v = node[u].son[col];
            if (!v) {
                v = ++ tot;
                node[v].fa = u;
                node[v].col = col;
                node[v].dep = node[u].dep + 1;
            }
            u = v;
            if (!vis[v]) {
                c.push_back(v);
            }
        }
        vis[c.back()] = 1;
    }
    for (auto x : c) vis[x] = 0;
    return c;
}

int ins(const vi &s, int u) {
    for (auto c : s) {
        int &v = node[u].son[c];
        if (!v) {
            v = ++ tot;
            node[v].fa = u;
            node[v].col = c;
            node[v].dep = node[u].dep + 1;
        }
        u = v;
    }
    return u;
}

void ins(const vi &s) {
    vi a(0);
    int lst_tot = tot;
    for (int i = 1; i <= cnt; i ++) {
        a = ins(s, cur[i], a);
    }
    static vi b[MAX_N];
    for (int i = 0; i < (int)a.size(); i ++) {
        b[i].clear();
        for (int u = a[i]; u; u = node[u].fa) {
            b[i].push_back(node[u].col);
        }
        reverse(b[i].begin(), b[i].end());
    }
    for (int i = tot; i > lst_tot; i --) {
        node[node[i].fa].son[node[i].col] = 0;
        node[i].dep = 0; node[i].col = 0; node[i].fa = 0;
    }
    tot = lst_tot; cnt = a.size();
    for (int i = 0; i < (int)a.size(); i ++) {
        cur[i + 1] = ins(b[i], 0);
    }
}

void dfs(int u, string &s) {
    if (idx[u]) {
        pat[idx[u]] = s;
    }
    for (int i = 0; i < 52; i ++) {
        if (node[u].son[i]) {
            s.push_back((char)(i < 26 ? i + 'A' : i - 26 + 'a'));
            dfs(node[u].son[i], s);
            s.pop_back();
        }
    }
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0); cout.tie(0);
    
    cin >> N;
    string trash;
    getline(cin, trash);
    for (int i = 1; i <= N; i ++) {
        vi s;
        string t;
        getline(cin, t);
        cur[cnt = 1] = 0;
        for (int j = 0, k; j < (int)t.size(); j ++) {
            for (k = j; k < (int)t.size() && t[k] != ' '; k ++);
            s.resize(k - j);
            auto it = s.begin();
            while (j < k) {
                *it = t[j] <= 'Z' ? t[j] - 'A' : t[j] - 'a' + 26;
                j ++; it ++;
            }
            assert(it == s.end());
            ins(s);
        }
        assert(cnt <= N);
        for (int j = 1; j <= cnt; j ++) {
            if (!idx[cur[j]]) {
                idx[cur[j]] = ++ M;
                w[M] = node[cur[j]].dep;
            }
            add_edge(i, N + idx[cur[j]], 1, 0);
        }
    }
    string sta;
    dfs(0, sta);
    s = M + N + 1; t = s + 1;
    for (int i = 1; i <= N; i ++) {
        add_edge(s, i, 1, 0);
    }
    for (int i = 1; i <= M; i ++) {
        add_edge(i + N, t, 1, w[i]);
    }
    while (spfa());
    if (flow < N) {
        cout << "no solution\n";
        return 0;
    }
    for (int i = 2; i <= ecnt; i += 2) {
        auto [y, trash1, cap, trash2] = e[i];
        auto [x, trash3, rcap, trash4] = e[i ^ 1];
        if (x <= N && rcap) {
            ans[x] = pat[y - N];
        }
    }
    for (int i = 1; i <= N; i ++) {
        cout << ans[i] << '\n';
    }
    
    return 0;
}