#include <algorithm>
#include <iostream>
#include <sstream>
#include <tuple>
#include <unordered_map>
#include <utility>
#include <vector>

using namespace std;

constexpr int N = 128, L = 256, M = N * N + 1, A = 26;

int nx[M][2 * A], par[M], tm[M], ct = 1;
vector<int> bydepth[L + 1];
unordered_map<string, int> id;
vector<int> nei[M];
int mt[N], vis[M];

int getid(const string& s) { return id.emplace(s, id.size()).first->second; }

bool trymatch(int v) {
  vis[v] = ct;
  for (auto& u: nei[v]) if (!~mt[u] || vis[mt[u]] != ct && trymatch(mt[u])) return mt[u] = v, 1;
  return 0;
}

int main() {
  cin.tie(0)->sync_with_stdio(0);
  int n; cin >> n; cin.ignore();
  for (int i = 0; i < n; ++i) {
    string s;
    getline(cin, s);
    stringstream ss(s);
    int nnodes = 1;
    static vector<int> old[L + 1];
    old[0].push_back(0);
    for (string s; ss >> s; ++ct) {
      for (auto& c: s) c -= c >= 'a'? 'a' - A: 'A';
      static int freshpos[L + 1];
      static vector<pair<int, int>> fresh[L + 1];
      int l = 0, cfresh = 0;
      while (l < L && cfresh < n) {
        int v = -1, i = 0;
        if (freshpos[l] < fresh[l].size()) tie(v, i) = fresh[l][freshpos[l]++];
        else if (old[l].size()) v = old[l].back(), old[l].pop_back();
        if (!~v) { ++l; continue; }
        if (i == s.size()) continue;
        if (!nx[v][s[i]]) {
          nx[v][s[i]] = nnodes;
          par[nnodes++] = v << 6 | s[i];
        }
        if (tm[nx[v][s[i]]] != ct) {
          fresh[l + 1].push_back({nx[v][s[i]], i + 1});
          ++cfresh, tm[nx[v][s[i]]] = ct;
        }
      }
      for (auto& old: old) old.clear();
      for (int l = 0; l <= L; freshpos[l++] = 0)
      for (auto& [v, i]: fresh[l]) old[l].push_back(v);
      for (auto& fresh: fresh) fresh.clear();
    }
    for (auto& old: old) {
      for (auto v: old) {
        string s;
        while (v) {
          v = par[v];
          s += char(v % 64);
          v /= 64;
        }
        nei[getid(s)].push_back(i);
      }
      old.clear();
    }
    for (int i = 0; i < nnodes; ++i) nx[par[i] / 64][par[i] % 64] = 0, tm[i] = par[i] = 0;
  }
  vector<string> alab;
  for (auto& [k, v]: id) alab.push_back(k);
  sort(alab.begin(), alab.end(), [](auto& a, auto& b) { return a.size() < b.size(); });
  ct = 1;
  fill(mt, end(mt), -1);
  for (auto& s: alab) if (trymatch(getid(s))) ++ct;
  for (auto& [k, v]: id) alab[v] = {k.rbegin(), k.rend()};
  if (ct != n + 1) return cout << "no solution", 0;
  for (int i = 0; i < n; ++i, cout << '\n')
  for (auto c: alab[mt[i]]) cout << char(c + (c < A? 'A': 'a' - 26));
}