#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
// if you end up using long double, you need to set the floating point notation to fixed, and set the percision to be very high
typedef long double ld;

// contrsuct umaps like this, unordered_map<long long, int, custom_hash> safe_map;
// FIXED_RANDOM is static so it doesn not get redeclared between function calls
struct custom_hash {
    static uint64_t splitmix64(uint64_t x) {
        // http://xorshift.di.unimi.it/splitmix64.c
        x += 0x9e3779b97f4a7c15;
        x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
        x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
        return x ^ (x >> 31);
    }

    size_t operator()(uint64_t x) const {
		
        static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
        return splitmix64(x + FIXED_RANDOM);
    }
};


#define INF 2001001001
#define INF2 2e18
#define MOD 1000000007

#define f0r(a, b) for (long long a = 0; a < b; a++)
#define f1r(a, b, c) for(long long a = b; a < c; a++)
#define max3(a, b, c) max(a, max(b, c))
#define min3(a, b, c) min(a, min(b, c))
#define pb push_back 
#define pf push_front
#define f first
#define s second
#define mp make_pair
#define pll pair<ll, ll>
#define pii pair<int, int>
#define tp make_tuple

// first four are north, west, east ,south
int dir1[] = {1, 0, -1, 0, 1, 1, -1, -1};
int dir2[] = {0, 1, 0, -1, 1, -1, 1, -1};

vector<int> vec;
vector<unordered_set<int, custom_hash>> edges;
int n;
bool done;
string ans1, ans2, ans3;

void recurse(int ind, vector<int>& vec1, vector<int>& vec2, vector<int>& vec3);
bool check(vector<int> cVec);

int main() {
	// apparently this does fast i/o
	cin.tie(0) , ios::sync_with_stdio(0);
	
	// use this if you read in from a file
	/*
	freopen("in.txt", "r", stdin);
    freopen("out.txt", "w", stdout);
	*/
	
	stringstream ss;
	
	// Do it once. Do it right.
	// Read the problem statement carefully
	// Plan out the steps in words on a piece of paper before implementing
	// after RTE(obviously) but also WA, run valgrind!!!
	
	//cout << fixed << setprecision(12);
	// if you use ld, use the above and don't use string stream
	
	// use instead of ceil(a, b) if a and b are positive
	// (a + b - 1) / b
	
	/*
	Sol: 
	ok so basically first you do some preprocessing work (checking to make sure each 3 letter word has all 3 characters unique, only need 18 or less letters
	picking extra letters if we need less than 18), then in theory theres only 18!/(6!^3*3!) combinations to check, but I don't know how to code that, I only
	can think of a way to code a 18/(6!^3) brute force. Basically each letter in the string is assigned some number 1-3 and we can prune at any point if we go
	over 6 characters assigned to a number, but you can still get like 6 letters being assigned all to 1, but then those 6 then get assigned to 3 so this method 
	doesn't get to divide by 3!. Then to check its 15*3, cause you can represent the 3 letter words as a graph, each node is a letter and it has edges to all the letters it can't 
	be on the same dice width, so then for each 6 character string, we just check all pairs. 
	Ok so you can actually check for validity as you do the recursion instead of doing it at the end
	just whenever you assign a new char a number, go through and check it against all chars previously assigned that number to make sure there is no edge between the two characters
	*/
	
	cin >> n;
	done = false;
	bool works = true;
	unordered_set<int, custom_hash> uset;
	edges.assign(26, unordered_set<int, custom_hash>());
	for(int i =0; i < n; i++){
		string temp;
		cin >> temp;
		if(temp[0] == temp[1] || temp[1] == temp[2] || temp[0] == temp[2]) works = false;
		for(int j =0; j < 3; j++){
			if(uset.find(temp[j]-'a') == uset.end()){
				vec.pb(temp[j]-'a');
				uset.insert(temp[j]-'a');
			}
			for(int k =0; k < 3; k++){
				if(k == j) continue;
				edges[temp[j]-'a'].insert(temp[k]-'a');
				edges[temp[k]-'a'].insert(temp[j]-'a');
			}
		}
		
	}
	/*
	for(int i = 0; i < vec.size(); i++){
		cout << (char)(vec[i]+'a');
	}
	cout << endl;
	for(int i = 0; i < 26; i++){
		for(auto a : edges[i]){
			cout << (char)(a+'a');
		}
		cout << endl;
	}
	*/
	if(uset.size() > 18) works = false;
	if(!works){
		cout << 0 << endl;
		return 0;
	}
	for(int i = 0; i < 26; i++){
		if(vec.size() >= 18) break;
		if(uset.find(i) == uset.end()) vec.pb(i);
	}
	vector<int> vec1, vec2, vec3;
	recurse(0, vec1, vec2, vec3);
	if(!done){
		cout << 0 << endl;
		return 0;
	}else{
		cout << ans1 << " " << ans2 << " " << ans3 << endl;
	}
	return 0;
}

void recurse(int ind, vector<int>& vec1, vector<int>& vec2, vector<int>& vec3){
	if(done) return;
	if(ind == 18){
		done = true;
		for(int i = 0; i < 6; i++){
			ans1.pb(vec1[i]+'a');
		}
		for(int i = 0; i < 6; i++){
			ans2.pb(vec2[i]+'a');
		}
		for(int i = 0; i < 6; i++){
			ans3.pb(vec3[i]+'a');
		}
	} 
	if(vec1.size() < 6){
		vec1.pb(vec[ind]);
		if(check(vec1)){
			recurse(ind+1, vec1, vec2, vec3);
		}
		vec1.pop_back();
	}
	
	if(vec2.size() < 6){
		vec2.pb(vec[ind]);
		if(check(vec2)){
			recurse(ind+1, vec1, vec2, vec3);
		}
		vec2.pop_back();
	}
	
	if(vec3.size() < 6){
		vec3.pb(vec[ind]);
		if(check(vec3)){
			recurse(ind+1, vec1, vec2, vec3);
		}
		vec3.pop_back();
	}
}

bool check(vector<int> cVec){
	bool works = true;
	int m = cVec.size();
	for(int i = 0; i < m-1; i++){
		if(edges[cVec[m-1]].find(cVec[i]) != edges[cVec[m-1]].end()){
			works = false;
			break;
		}
	}
	return works;
}