#include <bits/stdc++.h>
using namespace std;
ifstream f("adn.in");
ofstream g("adn.out");
#define cin f
#define cout g

int n;
vector < string > adn;
void read()
{
	f >> n;
	adn.resize(n);
	for(auto &it : adn)
		f >> it;
}
struct pq_elem{
	int val,nod,mask;
};
bool operator < (const pq_elem& p1, const pq_elem& p2)
{
	//operator overload
	//return true daca p2 are prioritate mai mare decat p1 
	//conditia pe dos
	return p1.val > p2.val;
}
bool kth(int mask, int k)
{
    return (mask & (1 << k)) != 0;
}
bool substringKMP(string &small, string &big)
{
	if(small.size() > big.size())return false;
	int target = small.size();
	string s = small + "#" + big;
	vector <int> pi (s.size ());
    pi[0] = 0;
    for (int i = 1; i < s.size (); i++) {
        int cur = pi[i - 1];
        while (cur && s[i] != s[cur])
            cur = pi[cur - 1];
        if (s[i] == s[cur])
            cur++;
        pi[i] = cur;
        if (pi[i] == target)
            return true;
    }
    return false;
}

void trimADN()
{
	// remove duplicates
	sort(adn.begin(), adn.end());
	adn.erase(unique(adn.begin(), adn.end()),adn.end());
	vector < bool > bad(adn.size());
	for(int i=0;i<adn.size();++i)
		for(int j = i+1;j<adn.size();++j)
		{
			if(substringKMP(adn[i],adn[j]))
				bad[i] = true;
			if(substringKMP(adn[j],adn[i]))
				bad[j] = true;
		}
	vector < string > finalADN;
	for(int i=0;i<adn.size();++i)
		if(!bad[i])
			finalADN.push_back(adn[i]);
	adn = finalADN;
}
int determineCostAdn(string& s1,string& s2)
{
	string s = s2 + "#" + s1;
	vector <int> pi (s.size ());
    pi[0] = 0;
    for (int i = 1; i < s.size(); i++) {
        int cur = pi[i - 1];
        while (cur && s[i] != s[cur])
            cur = pi[cur - 1];
        if (s[i] == s[cur])
            cur++;
        pi[i] = cur;
    }
    return pi[s.size()-1];
}
int cost[20][20];
int dp[19][(1 << 18) + 1];
pq_elem parent[19][(1 << 18) + 1];
void precomputeCosts()
{
	int i,j;
	for(int i=0;i<n;i++)
		for(int j=0;j<n;j++)
			if(i != j)
				cost[i][j] = determineCostAdn(adn[i],adn[j]);
}
void solve()
{
    trimADN();
    n = adn.size();
    precomputeCosts();
    priority_queue < pq_elem > pq;
        int all = (1 << n) - 1;
        for(int start = 0;start < n;start ++)
            {
                int mask = (1 << start);
                dp[start][mask] = 0;
                parent[start][mask] = {-1,-1,-1};
                pq.push({0,start,mask});
            }
        while(!pq.empty())
        {
            pq_elem state = pq.top();
            pq.pop();
            int nod = state.nod;
            int mask = state.mask;
            if(dp[nod][mask] != state.val)
                continue;
            for(int nxt = 0;nxt < n;nxt ++)
                if (!kth(mask,nxt))
                {
                    int ncost = state.val + cost[nod][nxt];
                    int nmask = mask | (1 << nxt);
                    if(ncost > dp[nxt][nmask])
                    {
                        dp[nxt][nmask] = ncost;
                        parent[nxt][nmask] = state;
                        pq.push({ncost,nxt,nmask});
                    }
                }
       	}
    pq_elem best = {-1,-1,-1};
	for(int i=0;i<n;i++)
		if(dp[i][all] > best.val)
			best = {dp[i][all],i,all};
	vector < int > sol;
	for(pq_elem nod = best;nod.nod != -1;nod = parent[nod.nod][nod.mask])
		sol.push_back(nod.nod);
    reverse(sol.begin(), sol.end());
	// rebuild the solution
	cout << adn[sol[0]];
	for(int i = 1;i<sol.size();i++)
	{
		int dif = cost[sol[i-1]][sol[i]];
		for(int j = dif;j < adn[sol[i]].size();++j)
			cout<<adn[sol[i]][j];
	}

}
void restart()
{

}
int32_t main()
{
    {
        read();
        solve();
        restart();
    }
    return 0;
}