Drazil is playing a math game with Varda.

Let's define <image> for positive integer x as a product of factorials of its digits. For example, <image>.

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. <image> = <image>.

Help friends find such number.

Input

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.

Output

Output a maximum possible integer satisfying the conditions above. There should be no zeroes and ones in this number decimal representation.

Examples

Input

4
1234


Output

33222


Input

3
555


Output

555

Note

In the first case, <image>
def is_prime(x):
	if (x <= 1):
		return False
	for i in xrange(2, x/2 + 1):
		if x % i == 0:
			return False
	return True

BASE = 10
digits = range(0, BASE)
prime_digits = []
for d in digits:
	if is_prime(d):
		prime_digits.append(d)


decomposition = {}	
for d in digits:
	decomposition[d] = {}
	for p in prime_digits:
		decomposition[d][p] = 0
	if (d <= 1):
		continue
	dd = d
	for p in prime_digits:
		while (dd % p == 0):
			dd /= p
			decomposition[d][p] += 1

decomposition_fa = {}
for p in prime_digits:
	decomposition_fa[p] = 0
n = int(raw_input())
a = raw_input()
for c in a:
	d = int(c)
	for t in xrange(2, d + 1):
		for p in prime_digits:
			decomposition_fa[p] += decomposition[t][p]
#print decomposition_fa


prime_digits.sort()
prime_digits.reverse()
#print prime_digits

res = ""
for p in prime_digits:	
	x = decomposition_fa[p]
	if (x <= 0):
		continue
	for i in xrange(p, 1, -1):
		for q in prime_digits:
			decomposition_fa[q] -= decomposition[i][q] * x
	res += x * str(p)
print res

			
	
