#include <cstdio>
#include <cstdlib>
#define INF (__INT32_MAX__ / 2)
#define MAX_N 100
#define MAX_W 10000

using namespace std;

int cost[9] = {2,5,5,4,5,6,3,7,6};    //num[i]のコストはcost[num[i] - 1]

int n;
int nums[MAX_N];     //ソート済みとする
int W;


int ddp[MAX_N][MAX_W + 1][MAX_N];
void sort(int *array, int left, int right);

int max(int left, int right) {
    return left > right ? left : right;
}

void array_copy(int *orig, int *copy, int left, int right) {
    for(int i = left; i < right; ++i)
        copy[i] = orig[i];
}

void print(int *array, int length) {
    for(int i = n - 1; i >= 0; --i)
        for(int j = 0; j < array[i]; ++j)
            printf("%i", nums[i]);
    printf("\n");
}

int cpa_value(int index, int *prev, int *cur, int cur_k) {
    //(以前の価値 - 今の価値)を返す
    //prev[]: index ~ n-1 に格納された, 作る数字の数を読み込む
    //tmp[]: index + 1 ~ n-1と, cur_kに格納された, 作る数字の数を読み込む
    
    int prev_sum = 0, cur_sum = cur_k;
    for(int i = index; i <= n; ++i) prev_sum += prev[i];
    for(int i = index + 1; i <= n; ++i) cur_sum += cur[i];
    if(prev_sum != cur_sum) return prev_sum - cur_sum;

    for(int i = n - 1; i >= index + 1; --i)
        if(prev[i] != cur[i])
            return prev[i] - cur[i];
    
    if(prev[index] != cur_k) return prev[index] - cur_k;
    return 0;
}

int main(int argc, char **argv) {
    scanf("%d", &W);
    scanf("%d", &n);

    for(int i = 0; i < n; ++i) {
        int tmp;
        scanf("%d", &tmp);
        nums[i] = tmp;
    }
    sort(nums, 0, n);


    //残り容量がないとき : ddp = 0

    //1つの数字も考慮しないとき(index = n)
    for(int w = 1; w <= W; ++w)     //マッチが残っている場合 -> 考慮しない -> ddp = -INF
        for(int i = 0; i <= n; ++i)
            ddp[n][w][i] = -INF;    

    //マッチが残っていないとき(w = 0) -> ddp = 0

    for(int index = n - 1; index >= 0; --index)
        for(int volume = 1; volume <= W; ++volume)
        {
            array_copy(ddp[index + 1][volume], ddp[index][volume], index + 1, n + 1);
            ddp[index][volume][index] = 0;
            for(int k = 1; true; ++k) {
                if(volume < cost[nums[index] - 1] * k) break;
                //if(max < tmp)
                if(cpa_value(index, ddp[index][volume], ddp[index + 1][volume - k * cost[nums[index] - 1]], k) < 0) {
                    array_copy(ddp[index + 1][volume - k * cost[nums[index] - 1]], ddp[index][volume], index + 1, n + 1);
                    ddp[index][volume][index] = k;
                }
            }
            
        }

    print(ddp[0][W], n);
}


int buf[10];
void sort(int *array, int left, int right) {
    right--;
    if(left < right)
    {
        int mid = (left + right) / 2;

        sort(array, left, mid + 1);
        sort(array, mid + 1, right + 1);

        //merge
        int left_len = mid - left + 1;
        int right_len = right - mid;

        int i_left = 0;
        int i_right = 0;


        for(int i = 0; i < left_len + right_len; ++i)
        {
            if (i_left < left_len &&
                (i_right >= right_len || array[left + i_left] <= array[mid + 1 + i_right]))
                buf[i] = array[left + i_left++];
            else if (i_right < right_len)
                buf[i] = array[mid + 1 + i_right++];
            else
                break;
        }

        for(int i = 0; i < left_len + right_len; ++i)
            array[left + i] = buf[i];
    }
}

Measured memory_bytes: 41088