#include <iostream>
#include <vector>
#include <string>
#include <algorithm>

using namespace std;

int main() {
    int n;
    cin >> n;
    vector<string> nums(n);
    for (int i = 0; i < n; i++) {
        cin >> nums[i];
    }

    sort(nums.begin(), nums.end()); // Bắt đầu từ hoán vị nhỏ nhất
    string max_str = "";

    do {
        string current = "";
        for (const string& s : nums) {
            current += s;
        }
        if (current > max_str) {
            max_str = current;
        }
    } while (next_permutation(nums.begin(), nums.end()));

    cout << max_str << endl;
    return 0;
}

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

// Hàm so sánh cho qsort
int cmp(const void *a, const void *b) {
    char *x = *(char **)a;
    char *y = *(char **)b;

    // Tạo 2 chuỗi đại diện cho việc nối 2 cách
    char ab[25]; // Đủ lớn để chứa cả 2 chuỗi (max 10^5 + 10^5)
    char ba[25];

    strcpy(ab, x);
    strcat(ab, y);

    strcpy(ba, y);
    strcat(ba, x);

    // So sánh 'xy' và 'yx'. 
    // Nếu 'xy' > 'yx', strcmp trả về số dương, nhưng qsort cần số âm để sắp xếp giảm dần?
    // Không, ta muốn 'xy' > 'yx' thì x phải đứng trước y (giảm dần).
    // Qsort mặc định sắp xếp tăng dần. Nếu return > 0, a đứng sau b.
    // Ta muốn nếu 'xy' > 'yx', thì a (x) phải đứng trước b (y) -> return âm.
    // Nên return strcmp(ba, ab) hoặc strcmp(ab, ba) logic khác.
    // Logic chuẩn: Nếu xy > yx, ta muốn x trước y. strcmp(xy, yx) > 0.
    // Qsort: return < 0 -> a trước b. 
    // Ta cần return -1 nếu xy > yx.
    // => return -strcmp(ab, ba);

    return strcmp(ba, ab); // Nếu ab > ba (xy > yx), strcmp trả > 0. Ta cần âm -> return -strcmp(ab, ba)
    // Code mẫu trong file lại sort tăng rồi in ngược, hoặc sort giảm.
    // Code mẫu giải pháp 3 sort giảm: cmp return strcmp(ba, ab) (tức là so sánh yx vs xy).
    // Nếu xy > yx, strcmp(yx, xy) < 0 -> swap. 
    // Logic chuẩn để sort giảm dần:
    // Ta muốn xy > yx thì x trước y.
    // Nếu cmp(x, y) return < 0, x trước y.
    // Ta cần cmp(x, y) = -strcmp(xy, yx).
    // Nếu xy > yx, strcmp > 0 -> cmp return âm -> x trước y. Đúng.
}

int main() {
    int n;
    scanf("%d", &n);
    char **a = (char **)malloc(n * sizeof(char *));
    for (int i = 0; i < n; i++) {
        a[i] = (char *)malloc(12 * sizeof(char));
        scanf("%s", a[i]);
    }

    // Sắp xếp giảm dần
    // Để dùng qsort cho giảm dần, ta có thể:
    // 1. Đổi logic hàm cmp: return -strcmp(ab, ba)
    // 2. Hoặc sắp xếp tăng rồi lật mảng.
    // Code mẫu dưới đây dùng logic hàm cmp chuẩn để sort giảm:
    qsort(a, n, sizeof(char *), cmp);

    // In kết quả
    for (int i = 0; i < n; i++) {
        printf("%s", a[i]);
    }

    return 0;
}

// Hàm cmp để sort giảm dần:
int cmp_correct(const void *a, const void *b) {
    char *x = *(char **)a;
    char *y = *(char **)b;
    char xy[25], yx[25];
    strcpy(xy, x); strcat(xy, y);
    strcpy(yx, y); strcat(yx, x);
    // Nếu xy > yx, ta muốn x trước y (return âm)
    // Nếu xy < yx, ta muốn y trước x (return dương)
    return -strcmp(xy, yx);
}

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

void solve() {
    int n;
    scanf("%d", &n);
    char s[n][12];
    for (int i = 0; i < n; i++) {
        scanf("%s", s[i]);
    }

    // Bubble Sort manually implementing the custom logic
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            char s1s2[25], s2s1[25];
            strcpy(s1s2, s[i]); strcat(s1s2, s[j]);
            strcpy(s2s1, s[j]); strcat(s2s1, s[i]);

            // Nếu s[i] + s[j] < s[j] + s[i], hoán đổi (để sort giảm)
            if (strcmp(s1s2, s2s1) < 0) {
                char temp[12];
                strcpy(temp, s[i]);
                strcpy(s[i], s[j]);
                strcpy(s[j], temp);
            }
        }
    }

    for (int i = 0; i < n; i++) {
        printf("%s", s[i]);
    }
}

int main() {
    solve();
    return 0;
}