#include <bits/stdc++.h>

using namespace std;
constexpr int K = 52;

struct node {
    array<int, K> go;
    array<int, K> ep{};
    int d{-1};
    int epoch{0};
    array<int, 2> par{-1, -1};
};

constexpr int N = 1 << 16;
constexpr int S = 270;

vector<int> fr;
array<char, N> used;
array<char, N> kek;
array<node, N> all;

int create(int d, int par, int c) {
    int v = fr.back();
    fr.pop_back();
    used[v] = 1;
    all[v].epoch++;
    all[v].d = d;
    all[v].par = {par, c};
    return v;
}

void free(int v) {
    all[all[v].par[0]].go[all[v].par[1]] = -1;
    used[v] = 0;
    fr.push_back(v);
}

char toi(char c) {
    return c >= 'a' && c <= 'z' ? c - 'a' : 26 + c - 'A';
}

char rev(char c) {
    return c < 26 ? c + 'a' : c - 26 + 'A';
}


int main() {
    cin.tie(0)->sync_with_stdio(0);
    fr.resize(N);
    iota(fr.begin(), fr.end(), 0);
    reverse(fr.begin(), fr.end());
    map<string, vector<int>> gr;

    int root = create(0, -1, -1);
    int n = 128;
    cin >> n;
    array<vector<int>, S> sz;
    for (int i = 0; i < n; ++i) {
        for (int i = 1; i < N; ++i) {
            if (used[i]) {
                free(i);
            }
        }
        vector<int> where;
        string inp;
        if (!i)getline(cin, inp);
        getline(cin, inp);
        vector<string> words;
        {
            string z;
            for (auto c: inp) {
                if (c == ' ')words.push_back(z), z = {};
                else z += c;
            }
            words.push_back(z);
        }
        where.push_back(root);
        for (auto &w: words) {
            vector<int> tot;
            for (auto &v: sz)v.clear();
            for (auto &c: w)c = toi(c);
            for (int cr: where) {
                for (auto c: w) {
                    if (all[cr].ep[c] != all[cr].epoch || !~all[cr].go[c]) {
                        all[cr].go[c] = create(all[cr].d + 1, cr, c);
                        all[cr].ep[c] = all[cr].epoch;
                    }
                    cr = all[cr].go[c];
                    if (all[cr].d > 256) {
                        break;
                    }
                    if (!kek[cr]) {
                        tot.push_back(cr);
                        sz[all[cr].d].push_back(cr);
                        kek[cr] = 1;
                    }
                }
            }
            where.clear();
            for (int k = 0; k < sz.size(); ++k) {
                for (auto v: sz[k]) {
                    if (where.size() == n) {
                        free(v);
                    } else {
                        where.push_back(v);
                    }
                    kek[v] = 0;
                }
            }
        }
        for (auto v: where) {
            string s;
            while (v != root) {
                s += all[v].par[1];
                v = all[v].par[0];
            }
            reverse(s.begin(), s.end());
            gr[s].push_back(i);
        }
    }
    int L = gr.size();
    vector<vector<int>> g(L);
    vector<pair<string, vector<int>>> all;
    for (auto &[s, v]: gr) {
        all.push_back({s, v});
    }
    sort(all.begin(), all.end(), [&](auto &x, auto &y) {
        return x.first.size() < y.first.size();
    });
    for (int i = 0; i < L; ++i) {
        g[i] = all[i].second;
    }
    int timer = 0;
    vector<int> used(L, -1);
    vector<int> match(n, -1);
    auto dfs = [&](auto &&dfs, int v) -> bool {
        if (used[v] == timer)return 0;
        used[v] = timer;
        for (auto t: g[v]) {
//            assert(t >= 0 && t < match.size());
            if (!~match[t] || dfs(dfs, match[t])) {
                match[t] = v;
                return 1;
            }
        }
        return 0;
    };
    for (int v = 0; v < L; ++v) {
        timer += dfs(dfs, v);
    }
    if (timer != n) {
        cout << "no solution\n";
        return 0;
    }
    for (int i = 0; i < n; ++i) {
        auto re = all[match[i]].first;
        for (auto &c: re)c = rev(c);
        cout << re << "\n";
    }
}