//-----------------------------------------------------------------------
//	File:		prob.cc
//	Description:	Assemble fragmented message
//	Author:		Chau-Wen Tseng (tseng@cs.umd.edu)
//-----------------------------------------------------------------------

#include <stdlib.h>
#include <iostream.h>
#include <assert.h>

// Uncomment the following lines if using APCS classes
// #include "apvector.h"
// #include "apmatrix.h"
// #include "apstack.h"
// #include "apqueue.h"

#include "apstring.cpp"

//-----------------------------------------------------------------------
//  main
//-----------------------------------------------------------------------

int main()
{
	const int FRAGSIZE = 12;
	const int MAXFRAG = 100;
	apstring frag[MAXFRAG], result, str, marker, head, tail;
	int numFrag, i, k, maxOverlap, overlapIdx, overlapIdx2, slen;
	bool found;

	// read in all fragments

	cin >> numFrag;
	for (i = 0; i < numFrag; i++) {
		cin >> frag[i];
		if (frag[i].length() != FRAGSIZE) {
			cout << "ERROR, illegal fragment size " << frag[i] << endl;
		}
	}

	// find beginning marker, use as current result
	
	marker = apstring("ZZZ");
	slen = marker.length();
	found = false;

	for (i = 0; i < numFrag; i++) {
		if (marker == frag[i].substr(0, slen)) {
			result = apstring(frag[i]);
			frag[i] = frag[--numFrag];
			found = true;
			break;
		}
	}

	if (!found) {
		cout << "ERROR, no fragment with initial marker " << marker << endl;
	}

	// assemble fragments

	while (numFrag > 0) {

		// find fragment with greatest overlap to end of current result

		maxOverlap = 0;
		overlapIdx2 = -1;

		for (i = 0; i < numFrag; i++) {

			// check if entire fragment is subsumed in string
			while (result.find(frag[i]) != npos) {
				frag[i] = frag[--numFrag];
			}

			if (i == numFrag)  // no more fragments
				break;

			for (k = maxOverlap+1; k < FRAGSIZE; k++) {
				head = frag[i].substr(0,k);
				tail = result.substr(result.length() - k, k);
				if (head == tail) {
					if (k > maxOverlap) {
						maxOverlap = k;
						overlapIdx = i;
					}
					else if (k == maxOverlap) {
						overlapIdx2 = i;
					}
				}
			}
		}

		// append fragment with greatest overlap to end of current result

		if (maxOverlap > 0) {
			// cout << "Merging " << maxOverlap << " " << result << " " << frag[overlapIdx];
			result += frag[overlapIdx].substr(maxOverlap, FRAGSIZE-maxOverlap);
			frag[overlapIdx] = frag[--numFrag];

			if (overlapIdx2 >= 0) {
				cout << "Error, found multiple fragments with max overlap: " << endl;
				cout << frag[overlapIdx] << " && " << frag[overlapIdx2] << endl;
			}
		}
		else {
			cout << "Error, unable to assemble complete message " << endl;
			cout << "Remaining fragments: \n";
			for (k = 0; k < numFrag; k++) {
				cout << frag[k] << endl;
			}
			break;
		}
	}

	cout << result.substr(slen, result.length()-slen) << endl;

	return 0;
}