Drazil is playing a math game with Varda.

Let's define <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/7020b94c48be2ee5b8eeca05f379c8911bb0e7c4.png" style="max-width: 100.0%;max-height: 100.0%;"/> for positive integer *x* as a product of factorials of its digits. For example, <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/6784d861d9a724d0aeddefcb00b7d0c3442ae586.png" style="max-width: 100.0%;max-height: 100.0%;"/>.

First, they choose a decimal number *a* consisting of *n* digits that contains at least one digit larger than 1. This number may possibly start with leading zeroes. Then they should find maximum positive number *x* satisfying following two conditions:

1. *x* doesn't contain neither digit 0 nor digit 1.

2. <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/7020b94c48be2ee5b8eeca05f379c8911bb0e7c4.png" style="max-width: 100.0%;max-height: 100.0%;"/> = <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/aa57e017a6c74d06b0a54bc47e3f6990e5af38c1.png" style="max-width: 100.0%;max-height: 100.0%;"/>.

Help friends find such number.
The first line contains an integer *n* (1 ≤ *n* ≤ 15) — the number of digits in *a*.

The second line contains *n* digits of *a*. There is at least one digit in *a* that is larger than 1. Number *a* may possibly contain leading zeroes.
'''
We will describe a few properties.

Notice that the given number a, will be a composition of digits. For now,
assume a is a single digit.

Given 2 <= k <= 9, the goal is to decompose k! into x_{1}! * ... * x_{i}!
and maximize i because adding an additional digit would increase the value
of x by an order of 10. Clearly, x_{j} <= k

Let's assume k is a prime, then the only representation is k! because
we must have x_{i} <= k, but if x_{i} < k then it is not possible for
k | x_{i}!.

Then, it follows that we must decompose into prime factorials for any k
in order to maximize i.


Here would be the optimal decomposition of each digit:
2 -> 2
3 -> 3
4 -> 3, 2, 2
5 -> 5
6 -> 5, 3
7 -> 7
8 -> 7, 2, 2, 2 
9 -> 7, 3, 3, 2

Now for a combination of digits we just combine these digits (possibly
multiple times), concatenate them, and reverse-sort them.
'''

NUMBER_DECOMPOSITION_LOOKUP = { "0": [], "1": [], "2": [2], "3": [3],
                                "4": [3, 2, 2], "5": [5], "6": [5, 3],
                                "7": [7], "8": [7, 2, 2, 2],
                                "9": [7, 3, 3, 2]}


def findMaximalNumber(digits: str) -> str:
    
    decomposedDigits = []
    for digit in digits:
        decomposedDigits += NUMBER_DECOMPOSITION_LOOKUP[digit]
    decomposedDigits.sort(reverse=True)
    return ''.join([str(i) for i in decomposedDigits])

length = input()
digits = input()
print(findMaximalNumber(digits))