import java.io.*;
import java.math.*;
import java.util.*;
import static java.lang.Math.*;

public class Timus_1587 implements Runnable {

    StreamTokenizer tok;
    BufferedReader in;
    PrintWriter out;
    boolean timus = System.getProperty("ONLINE_JUDGE") != null;

    void init() throws IOException {
        if (timus) {
            in = new BufferedReader(new InputStreamReader(System.in));
            tok = new StreamTokenizer(in);
            out = new PrintWriter(System.out);
        } else {
            in = new BufferedReader(new FileReader("input.txt"));
            tok = new StreamTokenizer(in);
            out = new PrintWriter("output.txt");
        }
    }

    int readInt() throws IOException {
        tok.nextToken();
        return (int) tok.nval;
    }

    String readString() throws IOException {
        tok.nextToken();
        return tok.sval;
    }

    public static void main(String[] args) {
        new Thread(new Timus_1587()).start();
    }

    @Override
    public void run() {
        try {
            if (timus) {
                init();
                solve();
                out.flush();
            } else {
                long t1 = System.currentTimeMillis();
                init();
                solve();
                out.close();
                long t2 = System.currentTimeMillis();
                System.out.println(t2 - t1);
            }
        } catch(IOException e) {
            System.exit(1);
        }
    }

    int compare(int twos1, int threes1, int twos2, int threes2) {
        double pow1 = twos1 * log(2) + threes1 * log(3);
        double pow2 = twos2 * log(2) + threes2 * log(3);
        if (pow1 > pow2) return 1;
        if (pow1 < pow2) return -1;
        return 0;
    }

    BigInteger calculateAnswer(int twos, int threes) {
        BigInteger x = BigInteger.valueOf(2).pow(twos);
        BigInteger y = BigInteger.valueOf(3).pow(threes);
        return x.multiply(y);
    }

    void solve() throws IOException {
        int n = readInt();
        int[] a = new int[n + 1];
        for (int i = 1; i <= n; i++) {
            a[i] = readInt();
        }
        if (n == 1) {
            out.println(a[n]);
            return;
        }
        int[] d2pos = new int[n + 1]; Arrays.fill(d2pos, -1);
        int[] d2neg = new int[n + 1]; Arrays.fill(d2neg, -1);
        int[] d3pos = new int[n + 1]; Arrays.fill(d3pos, -1);
        int[] d3neg = new int[n + 1]; Arrays.fill(d3neg, -1);
        for (int i = 1; i <= n; i++) {
            int c = a[i];
            switch (c) {
            case 1:
                d2pos[i] = max(d2pos[i - 1], 0);
                d3pos[i] = max(d3pos[i - 1], 0);
                if (d2neg[i - 1] >= 0) d2neg[i] = d2neg[i - 1];
                if (d2neg[i - 1] >= 0) d3neg[i] = d3neg[i - 1];
                break;
            case 2:
                d2pos[i] = max(d2pos[i - 1], 0) + 1;
                d3pos[i] = max(d3pos[i - 1], 0);
                if (d2neg[i - 1] >= 0) d2neg[i] = d2neg[i - 1] + 1;
                if (d3neg[i - 1] >= 0) d3neg[i] = d3neg[i - 1];
                break;
            case 3:
                d2pos[i] = max(d2pos[i - 1], 0);
                d3pos[i] = max(d3pos[i - 1], 0) + 1;
                if (d2neg[i - 1] >= 0) d2neg[i] = d2neg[i - 1];
                if (d3neg[i - 1] >= 0) d3neg[i] = d3neg[i - 1] + 1;
                break;
            case -1:
                if (d2neg[i - 1] >= 0) d2pos[i] = d2neg[i - 1];
                if (d3neg[i - 1] >= 0) d3pos[i] = d3neg[i - 1];
                d2neg[i] = max(d2pos[i - 1], 0);
                d3neg[i] = max(d3pos[i - 1], 0);
                break;
            case -2:
                if (d2neg[i - 1] >= 0) d2pos[i] = d2neg[i - 1] + 1;
                if (d3neg[i - 1] >= 0) d3pos[i] = d3neg[i - 1];
                d2neg[i] = max(d2pos[i - 1], 0) + 1;
                d3neg[i] = max(d3pos[i - 1], 0);
                break;
            case -3:
                if (d2neg[i - 1] >= 0) d2pos[i] = d2neg[i - 1];
                if (d3neg[i - 1] >= 0) d3pos[i] = d3neg[i - 1] + 1;
                d2neg[i] = max(d2pos[i - 1], 0);
                d3neg[i] = max(d3pos[i - 1], 0) + 1;
                break;
            }
        }
        int maxIndex = 0;
        for (int i = 1; i <= n; i++) {
            if (compare(d2pos[i], d3pos[i],
                    d2pos[maxIndex], d3pos[maxIndex]) == 1) {
                maxIndex = i;
            }
        }
        if (d2pos[maxIndex] < 0 || d3pos[maxIndex] < 0) {
            int max = a[1];
            for (int i = 2; i <= n; i++) {
                max = max(max, a[i]);
            }
            out.println(max);
            return;
        }
        BigInteger ans = calculateAnswer(d2pos[maxIndex], d3pos[maxIndex]);
        out.println(ans);
    }

}