#include <stdio.h>
#include <iostream>
#include <vector>

using namespace std;

const int maxN = 21;
const int maxC = 32002;
const int maxCD = (1<<18);
const int modH = 666013;
const int bzH = 19;

int N;
int dMin[ maxN ][ maxCD ];
int parent[ maxN ][ maxCD ];
char str[ maxN ][ maxC ];
char tmp[ maxN ][ maxC ];
int ln[ maxN ];

int solOrd[ maxN ];

int supp[ maxN ][ maxN ];
int lC;

long long hash1, hash2;

long long powF( int bz, int exp ) {
    long long rez = 1;
    long long aux = bz;
    for ( int i = 0; i < 16; i++ ) {
        if ( exp & ( 1 << i ) )
           rez = ( rez * aux ) % modH;
        aux = ( aux * aux ) % modH;
    }
    return rez;
}

bool eok( int X, int K ) {
    int R = 0;
    for ( int i = 0; i < maxN; i++ )
        if (  (1<<i) & K ) R++;
    return ( R == X );
}

int main()
{
#ifndef PC_COMPILE
    freopen("adn.in","r",stdin);
    freopen("adn.out","w",stdout);
#endif
#ifdef PC_COMPILE
	freopen("data.in","r",stdin);
	freopen("data.out","w",stdout);
#endif

	scanf("%d\n", &N );

	for ( int i = 0; i < N; i++ ) {
		scanf("%s\n", tmp[ i ] );
		ln[i] = strlen( tmp[i] );
		dMin[i][ (1<<i) ] = ln[i];
	}
    int M =0;
    for ( int i = 0; i < N; i++ ) {
        hash1 = 0;
        for ( int j = 0; j < ln[i]; j++ )
            hash1 = ( hash1 + tmp[i][j]*powF( bzH, ln[i]-(j+1) ) ) % modH;
        int ins = 1;

        for ( int j = 0 && ins; j < N; j++ )
            if ( ln[i] <= ln[j] && i != j) {
                hash2 = 0;
                for ( int k = 0; k < ln[i]; k++ )
                    hash2 = ( hash2 + tmp[j][k]*powF( bzH, ln[i]-(k+1) ) ) % modH;
                if ( hash1 == hash2 ) {
                    ins = 0;
                    break;
                }
                for ( int k = ln[i]; k < ln[j]; k++ ) {
                    hash2 = ( hash2 + 100*modH - tmp[j][k-ln[i]]*powF( bzH, ln[i]-1 ) ) % modH;
                    hash2 = ( hash2 * bzH + tmp[j][k] ) % modH;
                    if ( hash2 == hash1 ) {
                        ins = 0;
                        break;
                    }

                }
            }
        if ( ins ) {
            memcpy( str[M], tmp[i], sizeof( tmp[i] ) );
            M++;
        }
    }
    memset( ln, 0, sizeof( ln ) );
    N = M;
    for ( int i = 0; i < N; i++ ) {
		ln[ i ] = strlen( str[i] );
		supp[ N ][ i ] = 1;
    }
	for ( int i = 0; i < N; i++ )
		for ( int j = 0; j < N; j++ ) {
            hash1 = 0, hash2 = 0;

            for ( int l = 1; l <= min( ln[i], ln[j] ); l++ ) {
                hash1 = ( hash1 + str[i][ ln[i] - l ]*powF( bzH, l-1 ) ) % modH;
                hash2 = ( hash2*bzH + str[j][ l-1 ] ) % modH;

                if ( hash1 == hash2 )
                    supp[i][j] = l;
            }
	}

	for ( int i = 0; i < N-1; i++ )
        for ( int j = 0; j < N; j++ ) {
            for ( int k = ( 1 << j ); k < ( 1<<N ); k++ )
                if ( eok( i, k ) && dMin[j][k] ) {
                    for ( int l = 0; l < N; l++ )
                        if ( ! ( (1<<l) & k ) ) {
                            if ( dMin[l][ k + (1<<l) ] > dMin[j][k] + ln[l] - supp[j][l] || !dMin[l][ k+(1<<l) ] )
                                dMin[l][ k+(1<<l) ] = dMin[j][k] + ln[l] - supp[j][l];
                                parent[l][ k+(1<<l ) ] = j;
                        }
                }
        }
    int sol = 0;
    int cfgSol = (1<<N)-1;

    for ( int i = 0; i < N; i++ ) {
        if ( dMin[ i ][ cfgSol ] < dMin[ sol ][ cfgSol ] )
            sol = i;
            //printf("Min : %d\n", dMin[N-1][i][cfgSol] );
    }

	int i = N-1;
	while ( cfgSol ) {
        solOrd[ i ] = sol;
        sol = parent[ sol ][ cfgSol ];
        cfgSol -= ( 1 << solOrd[i] );
        i--;
	}
	solOrd[N] = N+1;
	for ( int i = 0; i < N; i++ ) {
	    for ( int j = 0; j < ln[ solOrd[i] ] - supp[ solOrd[i] ][ solOrd[i+1] ]; j++ )
            printf("%c", str[ solOrd[i] ][ j ] );
	}
	printf("\n");
    return 0;
}