use std::io::{self,Read};
use std::str::Chars;
use std::iter::FromIterator;

struct Source<'a> { chars: Chars<'a> }

#[allow(dead_code)]
impl<'a> Source<'a> {
    fn next_chr(&mut self) -> char {
        self.chars.by_ref()
            .skip_while(|c| char::is_whitespace(*c))
            .next()
            .expect("eof")
    }

    fn next_str(&mut self) -> String {
        let it = self.chars.by_ref()
            .skip_while(|c| char::is_whitespace(*c))
            .take_while(|c| !char::is_whitespace(*c));
        let s = String::from_iter(it);
        if s.len() == 0 {
            panic!("eof")
        } else {
            s
        }
    }
}

#[allow(unused_macros)]
macro_rules! input {
    (src = $str:expr; $($elem:tt)*) => {
        let mut src = Source {
            chars: $str.chars(),
        };

        input_inner!(src, $($elem)*)
    };
    ($($elem:tt)*) => {
        let mut data = String::new();
        io::stdin().read_to_string(&mut data).expect("Input error");
        let mut src = Source {
            chars: data.chars(),
        };

        input_inner!(src, $($elem)*)
    };
}

#[allow(unused_macros)]
macro_rules! input_inner {
    ($src:expr) => {};
    ($src:expr,) => {};
    ($src:expr, $var:ident : mut $ty:tt $($rest:tt)*) => {
        let mut $var = parse!($src, $ty);
        input_inner!($src $($rest)*)
    };
    ($src:expr, $var:ident : $ty:tt $($rest:tt)*) => {
        let $var = parse!($src, $ty);
        input_inner!($src $($rest)*)
    };
}

#[allow(unused_macros)]
macro_rules! parse {
    ($src:expr, ( $($ty:tt),* )) => {
        ( $(parse!($src,$ty)),* )
    };
    ($src:expr, char) => {
        $src.next_chr()
    };
    ($src:expr, [ $ty:tt; $len:expr ]) => {
        (0..$len).map(|_| parse!($src,$ty)).collect::<Vec<_>>()
    };
    ($src:expr, $ty:tt) => {
        parse_str!($src,$ty)
    };
}

#[allow(unused_macros)]
macro_rules! parse_str {
    ($src:expr, chars) => {
        $src.next_str().chars().collect::<Vec<char>>()
    };
    ($src:expr, $ty:ty) => {
        $src.next_str().parse::<$ty>().expect("Parse error")
    };
}

use std::cmp::*;
use std::fmt;

#[derive(Clone,Copy,PartialEq,Eq)]
struct Number {
    d: usize,
    count: [usize; 10],
}

impl Number {
    fn zero() -> Number {
        Number {
            d: 0,
            count: [0; 10],
        }
    }
}

fn compare_count(a: &[usize; 10], b: &[usize; 10]) -> Ordering {
    (1..10).rev().fold(Ordering::Equal, |ord,i| {
        match ord {
            Ordering::Equal => a[i].cmp(&b[i]),
            otherwise => otherwise
        }
    })
}

impl PartialOrd for Number {
    fn partial_cmp(&self, other: &Number) -> Option<Ordering> {
        Some(self.cmp(other))
    }
}

impl Ord for Number {
    fn cmp(&self, other: &Number) -> Ordering {
        match self.d.cmp(&other.d) {
            Ordering::Equal => compare_count(&self.count,&other.count),
            otherwise => otherwise,
        }
    }
}

impl fmt::Display for Number {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        let mut s = String::new();
        for (i,&c) in self.count.iter().enumerate().rev() {
            for _ in 0..c {
                s.push_str(&i.to_string());
            }
        }
        write!(f, "{}", s)
    }
}

fn main() {
    input! {
        n: usize, m: usize, a: [usize; m]
    }

    let req = [6,2,5,5,4,5,6,3,7,6];

    let mut dp = vec![None; n+1];
    dp[0] = Some(Number::zero());

    for i in 1..n+1 {
        for j in 0..m {
            if i >= req[a[j]] {
                if let Some(mut v) = dp[i-req[a[j]]] {
                    v.count[a[j]] += 1;
                    v.d += 1;
                    dp[i] = max(dp[i], Some(v));
                }
            }
        }
    }

    println!("{}",dp[n].unwrap());
}


Measured memory_bytes: 4352