//Ilie Dumitru
#include<cstdio>
#include<cstring>
#include<algorithm>
const int NMAX=20;
const int LENMAX=30005;

int N, len[NMAX];
char mat[NMAX][LENMAX];
int initPrefix[NMAX][LENMAX];
int combine[NMAX][NMAX];
int parent[1<<NMAX][NMAX];
int dp[1<<NMAX][NMAX];

struct sir
{
	char* s;
	int* prefix;
	int len;

	friend bool operator<(sir a, sir b)
	{
		return a.len<b.len;
	}
};
sir v[NMAX];

void genPrefix(int n)
{
	int i, q=0;

	for(i=1;i<=len[n];++i)
	{
		while(q && mat[n][q]!=mat[n][i])
			q=initPrefix[n][q];
		initPrefix[n][i]=q;
		if(q==0 || mat[n][q]==mat[n][i])
			++q;
	}
}

int getExtra(int a, int b)
{
	int i, q=0;
	for(i=1;i<=v[b].len;++i)
	{
		while(q && v[a].s[q+1]!=v[b].s[i])
			q=v[a].prefix[q];
		if(v[a].s[q+1]==v[b].s[i])
			++q;
	}
	return v[a].len-q;
}

void printSolution(int mask, int last, FILE* g)
{
	if(mask)
	{
		if(last==-1)
			while(last || last-1)
				--last;

		printSolution(mask^(1<<last), parent[mask][last], g);
		int extra=dp[mask][last]-dp[mask^(1<<last)][parent[mask][last]];
		fprintf(g, "%s", v[last].s+v[last].len-extra+1);
	}
}

int main()
{
	FILE* f=fopen("adn.in", "r"), *g=fopen("adn.out", "w");
	int i, j, mask, min;
	fscanf(f, "%d", &N);
	fgets(mat[0], LENMAX, f);
	for(i=0;i<N;++i)
	{
		fgets(mat[i]+1, LENMAX, f);
		v[i].s=mat[i];
		v[i].prefix=initPrefix[i];
		len[i]=strlen(mat[i]+1);
		if(mat[i][len[i]]=='\n')
			mat[i][len[i]--]=0;
		v[i].len=len[i];
		genPrefix(i);
	}

	std::sort(v, v+N);

	for(i=0;i<N;++i)
	{
		for(j=i+1;j<N;++j)
		{
			if(strstr(v[j].s+1, v[i].s+1))
			{
				for(j=i+1;j<N;++j)
					v[j-1]=v[j];
				--i;
				--N;
			}
		}
	}

	for(i=0;i<N;++i)
		for(j=0;j<N;++j)
			if(i!=j)
				combine[i][j]=getExtra(j, i);

	for(i=(1<<N)-1;i;--i)
	{
		for(j=0;j<N;++j)
		{
			dp[i][j]=NMAX*LENMAX;
			parent[i][j]=-1;
		}
	}

	for(i=0;i<N;++i)
		dp[1<<i][i]=v[i].len;

	for(mask=1;mask<(1<<N);++mask)
	{
		for(i=0;i<N;++i)
		{
			if(mask&(1<<i))
			{
				for(j=0;j<N;++j)
				{
					if((mask&(1<<j))==0)
					{
						//avem bit-ul i setat si bit-ul j nesetat
						if(dp[mask|(1<<j)][j]>dp[mask][i]+combine[i][j])
						{
							dp[mask|(1<<j)][j]=dp[mask][i]+combine[i][j];
							parent[mask|(1<<j)][j]=i;
						}
					}
				}
			}
		}
	}

	min=0;
	mask=(1<<N)-1;
	for(i=1;i<N;++i)
	{
		if(dp[mask][min]>dp[mask][i])
			min=i;
	}

	printSolution(mask, min, g);

	fclose(f);
	fclose(g);
	return 0;
}