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.BufferedReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.IOException;
import java.util.StringTokenizer;
import java.io.InputStream;
import java.io.InputStreamReader;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		TaskA solver = new TaskA();
		solver.solve(1, in, out);
		out.close();
	}
}

class TaskA {
    public void solve(int testNumber, InputReader in, PrintWriter out) {
        int n = in.nextInt();
        char num[] = in.next().toCharArray();

        int primes[] = primes(num);

        primes[0] -= primes[3];
        primes[1] -= primes[3];

        primes[0] -= 2 * primes[2];
        int len = primes[0];
        char ans[] = new char[len];
        for (int j = 0; j < len; j++) {
            if (primes[3] > 0) {
                ans[j] = '7';
                primes[3]--;
                primes[2]--;
                primes[1]--;
            } else if (primes[2] > 0) {
                ans[j] = '5';
                primes[2]--;
                primes[1]--;
            } else if (primes[1] > 0) {
                ans[j] = '3';
                primes[1]--;
            } else {
                ans[j] = '2';
            }
        }

        out.println(new String(ans));

    }

    private int[] primes(char[] num) {
        int ans[] = new int[4];
        for (int i = 0; i < num.length; i++) {
            int tmp[] = primes(num[i] - '0');
            for (int j = 0; j < 4; j++) {
                ans[j] += tmp[j];
            }
        }
        return ans;
    }

    private int[] primes(long num) {
        if (num == 0) return new int[]{0, 0, 0, 0};
        if (num == 1) return new int[]{0, 0, 0, 0};
        if (num == 2) return new int[]{1, 0, 0, 0};
        if (num == 3) return new int[]{1, 1, 0, 0};
        if (num == 4) return new int[]{3, 1, 0, 0};
        if (num == 5) return new int[]{3, 1, 1, 0};
        if (num == 6) return new int[]{4, 2, 1, 0};
        if (num == 7) return new int[]{4, 2, 1, 1};
        if (num == 8) return new int[]{7, 2, 1, 1};
        if (num == 9) return new int[]{7, 4, 1, 1};
        throw new RuntimeException();
    }
}

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());
    }
}

