import Control.Arrow
import Control.Monad
import Data.List
import qualified Data.ByteString.Char8 as B
import Data.Ord
import Data.Char
import Data.Function
import Control.Monad.State (State, evalState, gets, modify)
import Data.Map.Strict (Map, lookup, insert, empty)
import Data.Maybe

main :: IO ()
main = readLine >>= main'
    where
        main' [n, m] = readLine >>= putStrLn . solve n

solve :: Int -> [Int] -> String
solve n = build . choose n . map head . groupBy ((==) `on` snd) . sortBy cmpf . map acf
    where
        cmpf lhs rhs = comparing snd lhs rhs `mappend` comparing fst rhs lhs

        build = map (\x -> chr $ ord '0' + x) . sortBy (flip compare)

choose :: Int -> [(Int, Int)] -> [Int]
choose n ((a, ac) : as) = snd . maxFst $ map ans [0..r]
    where
        (r, m) = n `divMod` ac
        ninf = -100000

        maxFst = maximumBy (comparing fst)
        safeMaxFst xs@(_ : _) = return $ maxFst xs 
        safeMaxFst _ = Nothing

        ans x = edit . run memo $ m + y * ac
            where
                y = r - x
                edit (Just (c, res)) = (x + c, replicate x a ++ res)
                edit _ = (ninf, [])

        memo f i
            | i > 0 = safeMaxFst . map fromJust . filter (/= Nothing) <$> mapM next as
            | i < 0 = return Nothing
            | otherwise = return $ Just (0, [])
            where
                next (b, bc) = safeEdit b <$> f (i - bc)
                safeEdit b = fmap (first succ . second (b :))


acf :: Int -> (Int, Int)
acf a
    | a == 1 = (a, 2)
    | a == 7 = (a, 3)
    | a == 4 = (a, 4)
    | a `elem` [2, 3, 5] = (a, 5)
    | a `elem` [6, 9] = (a, 6)
    | otherwise = (a, 7)

type Memoizer a b = a -> State (Map a b) b

run :: (Ord a) => (Memoizer a b -> Memoizer a b) -> a -> b
run f = flip evalState empty . memoizeFix f

memoizeFix :: (Ord a) => (Memoizer a b -> Memoizer a b) -> Memoizer a b
memoizeFix f x = gets (Data.Map.Strict.lookup x) >>= maybe (f (memoizeFix f) x >>= ((<$) <*> (modify . Data.Map.Strict.insert x))) return

readLine :: IO [Int]
readLine = unfoldr (\s -> second (maybe B.empty snd . B.uncons) <$> B.readInt s) <$> B.getLine

readContents :: Int -> IO [[Int]]
readContents = flip replicateM readLine

