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.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.text.DecimalFormat;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.Deque;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Map;
import java.util.PriorityQueue;
import java.util.Scanner;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;
import java.util.Queue;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
public class Main {
    ArrayList<Integer> G = new ArrayList();
    void work() throws Exception{
        int n = Int();
        G.clear();
        String s = Next();
         for(char c : s.toCharArray()){
             switch(c){
                     case '2' :
                             G.add(2);
                             break;
                     case '3' :
                             G.add(3);
                             break;
                     case '4' :
                             G.add(3) ; G.add(2); G.add(2);
                             break;
                     case '5' :
                             G.add(5);
                             break;
                     case '6' :
                             G.add(5); G.add(3);
                             break;
                     case '7' :
                             G.add(7);
                             break;
                     case '8' :
                             G.add(7); G.add(2); G.add(2); G.add(2);
                             break;
                     case '9' :
                             G.add(7); G.add(3); G.add(3); G.add(2);
                             break;
             }
     }
        Collections.sort(G);
        for(int i = G.size()-1; i >= 0; i--)out.print(G.get(i)); out.println();
    }

    public static void main(String[] args) throws Exception{
        Main wo = new Main();
        in = new BufferedReader(new InputStreamReader(System.in));
        out = new PrintWriter(System.out);
  //    in = new BufferedReader(new InputStreamReader(new FileInputStream(new File("input.txt"))));
  //    out = new PrintWriter(new File("output.txt"));
        wo.work();
        out.close();
    }

    static int N = 3*100000+5;
    static int M = 101;
    DecimalFormat df=new DecimalFormat("0.0000");
    static int inf = (int)1e8;
    static long inf64 = (long) 1e18*2;
    static double eps = 1e-8;
    static double Pi = Math.PI;
    static int mod = (int)1e9 + 7 ;
    
    private String Next() throws Exception{
        while (str == null || !str.hasMoreElements())
            str = new StringTokenizer(in.readLine());
        return str.nextToken();
    }
    private int Int() throws Exception{
        return Integer.parseInt(Next());
    }
    private long Long() throws Exception{
        return Long.parseLong(Next());
    }
    private double Double() throws Exception{
        return Double.parseDouble(Next());
    }
    StringTokenizer str;
    static Scanner cin = new Scanner(System.in);
    static BufferedReader in;
    static PrintWriter out;
  /*  
    class Edge{
        int from, to, dis, nex;
        Edge(){}
        Edge(int from, int to, int dis, int nex){
            this.from = from;
            this.to = to;
            this.dis = dis;
            this.nex = nex;
        }
    }
    Edge[] edge = new Edge[M<<1];
    int[] head = new int[N];
    int edgenum;
    void init_edge(){for(int i = 0; i < N; i++)head[i] = -1; edgenum = 0;}
    void add(int u, int v, int dis){
        edge[edgenum] = new Edge(u, v, dis, head[u]);
        head[u] = edgenum++;
    }/**/
    int upper_bound(int[] A, int l, int r, int val) {// upper_bound(A+l,A+r,val)-A;
        int pos = r;
        r--;
        while (l <= r) {
            int mid = (l + r) >> 1;
            if (A[mid] <= val) {
                l = mid + 1;
            } else {
                pos = mid;
                r = mid - 1;
            }
        }
        return pos;
    }

    int Pow(int x, int y) {
        int ans = 1;
        while (y > 0) {
            if ((y & 1) > 0)
                ans *= x;
            y >>= 1;
            x = x * x;
        }
        return ans;
    }
    double Pow(double x, int y) {
        double ans = 1;
        while (y > 0) {
            if ((y & 1) > 0)
                ans *= x;
            y >>= 1;
            x = x * x;
        }
        return ans;
    }
    int Pow_Mod(int x, int y, int mod) {
        int ans = 1;
        while (y > 0) {
            if ((y & 1) > 0)
                ans *= x;
            ans %= mod;
            y >>= 1;
            x = x * x;
            x %= mod;
        }
        return ans;
    }
    long Pow(long x, long y) {
        long ans = 1;
        while (y > 0) {
            if ((y & 1) > 0)
                ans *= x;
            y >>= 1;
            x = x * x;
        }
        return ans;
    }
    long Pow_Mod(long x, long y, long mod) {
        long ans = 1;
        while (y > 0) {
            if ((y & 1) > 0)
                ans *= x;
            ans %= mod;
            y >>= 1;
            x = x * x;
            x %= mod;
        }
        return ans;
    }

    int gcd(int x, int y){
        if(x>y){int tmp = x; x = y; y = tmp;}
        while(x>0){
            y %= x;
            int tmp = x; x = y; y = tmp;
        }
        return y;
    }
    int max(int x, int y) {
        return x > y ? x : y;
    }

    int min(int x, int y) {
        return x < y ? x : y;
    }

    double max(double x, double y) {
        return x > y ? x : y;
    }

    double min(double x, double y) {
        return x < y ? x : y;
    }

    long max(long x, long y) {
        return x > y ? x : y;
    }

    long min(long x, long y) {
        return x < y ? x : y;
    }

    int abs(int x) {
        return x > 0 ? x : -x;
    }

    double abs(double x) {
        return x > 0 ? x : -x;
    }

    long abs(long x) {
        return x > 0 ? x : -x;
    }

    boolean zero(double x) {
        return abs(x) < eps;
    }
    double sin(double x){return Math.sin(x);}
    double cos(double x){return Math.cos(x);}
    double tan(double x){return Math.tan(x);}
    double sqrt(double x){return Math.sqrt(x);}
}