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>
//package pkg292a1;

import java.io.*;
import java.util.*;

public class Main {

    InputReader in;
    PrintWriter out;
    
    public static void main(String[] args) {
        new Main().Run();
    }
    
    private static int n;
    private static int[] Count = new int[10];
    
    void Solve() throws Exception{
        String s;
        n = in.nextInt();
        s = in.readLine();
        char[] c = s.toCharArray();
        for(int i = 1; i <= n; i++){
            int x = (int)c[i - 1] - 48;
            switch(x){
                case 2:
                    Count[2]++;
                    break;
                case 3:
                    Count[3]++;
                    break;
                case 4:
                    Count[2]+= 2; Count[3]++;
                    break;
                case 5:
                    Count[5]++;
                    break;
                case 6:
                    Count[5]++; Count[3]++;
                    break;
                case 7:
                    Count[7]++;
                    break;
                case 8:
                    Count[7]++; Count[2] += 3;
                    break;
                case 9:
                    Count[7]++; Count[3] += 2; Count[2]++;
                    break;
                default:
                    break;
            }
        }
        for(int i = 9; i >= 2; i--){
            if(Count[i] >= 0) for(int j = 1; j <= Count[i]; j++) out.print(i);
        }
    }
            
    public void Run(){
        try{
            File defaultInput = new File("text.inp");
            if(defaultInput.exists()) in = new InputReader("text.inp");
            else in = new InputReader();
            out = new PrintWriter(System.out);
            Solve();
            out.close();
        } catch (Exception e){
            e.printStackTrace();
            System.exit(261);
        }
    }
    
    class InputReader {
        BufferedReader reader;
    StringTokenizer tokenizer;
        
    InputReader() {
            reader = new BufferedReader(new InputStreamReader(System.in));
        }
        
    InputReader(String fileName) throws FileNotFoundException {
            reader = new BufferedReader(new FileReader(new File(fileName)));
    }
        
    String readLine() throws IOException {
            return reader.readLine();
    }
        
        String nextToken() throws IOException {
            while (tokenizer == null || !tokenizer.hasMoreTokens())
            tokenizer = new StringTokenizer(readLine());
            return tokenizer.nextToken();
    }
        
    boolean hasMoreTokens() throws IOException {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                String s = readLine();
                if (s == null) return false;
        tokenizer = new StringTokenizer(s);
            }
            return true;
    }
        
    int nextInt() throws NumberFormatException, IOException {
            return Integer.parseInt(nextToken());
    }
        
    long nextLong() throws NumberFormatException, IOException {
            return Long.parseLong(nextToken());
    }
        
        double nextDouble() throws NumberFormatException, IOException {
            return Double.parseDouble(nextToken());
    }
    }
}
