#include <iostream>
#include <vector>
#include <map>
#include <unordered_map>
#include <algorithm>

using namespace std;

vector<string> nums;
vector<bool> used;
map<size_t, int, greater<>> num_sizes;

template <typename T>
void log_vector(const vector<T>& vec, const string& prefix = "") {
    clog << prefix << endl;
    for (const T& item : vec) {
        clog << item << " ";
    }
    clog << endl;
}

bool can_form_combination(const size_t target_size,
                          const size_t remaining_size
) {
    if (remaining_size == 0) { return true; }
    for (auto& [size, count] : num_sizes) {
        if (size > remaining_size) { break; }
        if (count > 0) {
            count--;
            if (can_form_combination(target_size, remaining_size - size)) {
                return true;
            }
            count++;
        }
    }
    return false;
}

bool calc_used(const size_t target_size, const size_t remaining_size, const size_t start_idx = 0) {
    if (remaining_size == 0) { return true; }
    for (size_t i = start_idx; i < nums.size(); i++) {
        if (nums[i].size() > remaining_size) { continue; }
        used[i] = true;
        if (calc_used(target_size, remaining_size - nums[i].size(), i + 1)) {
            return true;
        }
        used[i] = false;
        if (calc_used(target_size, remaining_size, i + 1)) {
            return true;
        }
    }
    return false;
}

void output_from_used() {
    for (int i = 0; i < nums.size(); i++) {
        if (used[i]) { cout << nums[i]; }
    }
    cout << endl;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int nums_amount, target_size;
    cin >> target_size >> nums_amount;
    nums.resize(nums_amount), used.resize(nums_amount);
    for (int i = 0; i < nums_amount; i++) {
        cin >> nums[i];
    }
    sort(nums.begin(), nums.end(), [](const string& a, const string& b) {
        return a + b > b + a;
    });
    for (const string& num : nums) {
        num_sizes[num.size()]++;
    }
    log_vector(nums, "nums: ");
    // while (!can_form_combination(target_size, target_size)) {
    //     target_size--;
    // }
    clog << "target_size: " << target_size << endl;
    calc_used(target_size, target_size);
    log_vector(used, "used: ");
    output_from_used();

    return 0;
}