#include <cstdio>
#include <cstring>
#include <algorithm>

#define NMax 19
#define LMax 30005
#define Infinity 1000000000

using namespace std;

int N, L[NMax], Cost[NMax][NMax], DP[1<<NMax][NMax], F[1<<NMax][NMax];
char DNA[NMax][LMax];

inline void BuildPi (char A[], int n, int Pi[])
{
    int k=0;
    for (int i=2; i<=n; ++i)
    {
        while (k>0 and A[k+1]!=A[i]) k=Pi[k];
        if (A[i]==A[k+1]) ++k;
        Pi[i]=k;
    }
}

inline int KMP (char A[], int n, char B[], int m, int Pi[])
{
    int k=0;
    for (int i=1; i<=m; ++i)
    {
        while (k>0 and B[i]!=A[k+1]) k=Pi[k];
        if (B[i]==A[k+1]) ++k;
        if (k==n) return -1;
    }
    return k;
}

void BuildCost ()
{
    for (int i=0; i<N; ++i)
    {
        int Pi[LMax]; memset (Pi, 0, sizeof (Pi));
        BuildPi (DNA[i], L[i], Pi);
        for (int j=0; j<N; ++j)
        {
            if (i==j) continue;
            if (KMP (DNA[i], L[i], DNA[j], L[j], Pi)==-1)
            {
                memcpy (DNA[i], DNA[N-1], sizeof (DNA[N-1]));
                L[i]=L[N-1]; --i; --N;
                memset (DNA[N], 0, sizeof (DNA[N]));
                break;
            }
        }
    }
    for (int i=0; i<N; ++i)
    {
        int Pi[LMax]; memset (Pi, 0, sizeof (Pi));
        BuildPi (DNA[i], L[i], Pi);
        for (int j=0; j<N; ++j)
        {
            if (i==j) continue;
            Cost[j][i]=KMP (DNA[i], L[i], DNA[j], L[j], Pi);
        }
    }
    for (int i=0; i<N; ++i)
    {
        for (int j=0; j<N; ++j)
        {
            Cost[i][j]=L[j]-Cost[i][j];
        }
        Cost[N][i]=L[i];
    }
}

void Initialize ()
{
    for (int i=1; i<(1<<N); ++i)
    {
        for (int j=0; j<N; ++j)
        {
            DP[i][j]=Infinity;
            F[i][j]=N;
        }
    }
    for (int i=0; i<N; ++i)
    {
        DP[1<<i][i]=L[i];
    }
}

void SolveDP ()
{
    Initialize ();
    for (int Conf=1; Conf<(1<<N); ++Conf)
    {
        for (int i=0; i<N; ++i)
        {
            if (DP[Conf][i]<Infinity or !(Conf&(1<<i)))
            {
                continue;
            }
            for (int j=0; j<N; ++j)
            {
                if (i==j or !(Conf&(1<<j))) continue;
                if (DP[Conf^(1<<i)][j]+Cost[j][i]<DP[Conf][i])
                {
                    DP[Conf][i]=DP[Conf^(1<<i)][j]+Cost[j][i];
                    F[Conf][i]=j;
                }
            }
        }
    }
}

inline void Print (int Conf, int Last)
{
    if (Conf==0) return;
    Print (Conf^(1<<Last), F[Conf][Last]);
    for (int i=L[Last]+1-Cost[F[Conf][Last]][Last]; i<=L[Last]; ++i)
    {
        printf ("%c", DNA[Last][i]);
    }
}

void Solve ()
{
    BuildCost ();
    SolveDP ();
    int Last=0;
    for (int i=1; i<N; ++i)
    {
        if (DP[(1<<N)-1][i]<DP[(1<<N)-1][Last])
        {
            Last=i;
        }
    }
    freopen ("adn.out", "w", stdout);
    Print ((1<<N)-1, Last);
    printf ("\n");
}

void Read ()
{
    freopen ("adn.in", "r", stdin);
    scanf ("%d\n", &N);
    for (int i=0; i<N; ++i)
    {
        scanf ("%s\n", DNA[i]);
        L[i]=strlen (DNA[i]);
        for (int j=L[i]; j>0; --j)
        {
            DNA[i][j]=DNA[i][j-1];
        }
    }
}

int main()
{
    Read ();
    Solve ();
    return 0;
}