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>
import java.io.*;
import java.util.*;


public class drazil_factorial 
{
	static int n;
	static String s;
		
	public static void main(String args[])throws IOException
	{
		InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader sc = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        drazil_factorial df = new drazil_factorial();
        
        
        n = sc.nextInt();
        s = sc.next();
        int noOnes = 0;
        int noZeros = 0;
        LinkedList<Integer>[] graph = new LinkedList[10];
        for (int i = 0; i<10; i++)
        	graph[i] = new LinkedList<Integer>();
        
        graph[2].add(2);
        graph[3].add(3);
        
        graph[4].add(3);
        graph[4].add(2);
        graph[4].add(2);
        
        graph[5].add(5);
        
        graph[6].add(5);
        graph[6].add(3);
        
        graph[7].add(7);
        
        graph[8].add(7);
        graph[8].add(2);
        graph[8].add(2);
        graph[8].add(2);
        
        graph[9].add(7);
        graph[9].add(3);
        graph[9].add(3);
        graph[9].add(2);
        
        
        		
        
        LinkedList<Integer> num = new LinkedList<Integer>();
        for (int i = 0; i<s.length(); i++)
        {
        	if (s.charAt(i)==0 || s.charAt(i) == 1)
        		continue;
        	else
        	{
        		for (int iter : graph[s.charAt(i)-'0'])
        		{
        			num.add(iter);
        		}
        	}
        	
        }
        Collections.sort(num, Collections.reverseOrder());
        StringBuilder ans = new StringBuilder();
        for (int it : num)
        	ans.append(it);
        
        out.println(ans);
        out.close();
        out.flush();
	}

	 static class InputReader {
	        public BufferedReader reader;
	        public StringTokenizer tokenizer;

	        public InputReader(InputStream stream) {
	            reader = new BufferedReader(new InputStreamReader(stream), 32768);
	            tokenizer = null;
	        }

	        public String next() {
	            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
	                try {
	                    tokenizer = new StringTokenizer(reader.readLine());
	                } catch (IOException e) {
	                    throw new RuntimeException(e);
	                }
	            }
	            return tokenizer.nextToken();
	        }

	        public int nextInt() {
	            return Integer.parseInt(next());
	        }

	        public long nextLong() {
	            return Long.parseLong(next());
	        }
	    }
}

class pair
{
	
}
