// java solution

import java.io.ByteArrayInputStream; import java.io.IOException; import java.io.InputStream; import java.io.PrintWriter; import java.util.Arrays; import java.util.HashMap; import java.util.InputMismatchException; import java.util.Map;

public class THONTH { static InputStream is; static PrintWriter out; static String INPUT = "";

static void solve()
{
    int n = ni();
    int[] a = na(n);
    int[] b = new int[n];
    for(int i = 0;i < n;i++)b[i] = -a[i];
    SegmentTreeRMQ st = new SegmentTreeRMQ(b);
    cache = new HashMap<>();
    out.println(dfs(0, n, a, st));
}

static int mod = 1000000007;

static Map<Long, Long> cache;

static long dfs(int l, int r, int[] a, SegmentTreeRMQ st)
{

// int n = a.length; if(r-l == 1)return 1L; if((r-l)%2 == 0)return 0L; if(a[l] < a[l+1])return 0;

    long code = l*1000000007L + r;
    if(cache.containsKey(code))return cache.get(code);

    long ret = 0;
    int gminval = -st.min(l+1, r);
    if(a[l] < gminval)return 0;
    int prevmin = 10;
    for(int t = r-1;t >= l+1;){
        int ll = st.lastle(t, prevmin);
        if(ll == -1 || ll <= l)break;

// tr(l, r, ll); ret += dfs(l+1, ll, a, st) * dfs(ll, r, a, st) % mod; prevmin = -a[ll]; t = ll-1; } // tr(l, r, ret); ret %= mod; cache.put(code, ret); return ret; }

public static class SegmentTreeRMQ {
    public int M, H, N;
    public int[] st;

    public SegmentTreeRMQ(int n)
    {
        N = n;
        M = Integer.highestOneBit(Math.max(N-1, 1))<<2;
        H = M>>>1;
        st = new int[M];
        Arrays.fill(st, 0, M, Integer.MAX_VALUE);
    }

    public SegmentTreeRMQ(int[] a)
    {
        N = a.length;
        M = Integer.highestOneBit(Math.max(N-1, 1))<<2;
        H = M>>>1;
        st = new int[M];
        for(int i = 0;i < N;i++){
            st[H+i] = a[i];
        }
        Arrays.fill(st, H+N, M, Integer.MAX_VALUE);
        for(int i = H-1;i >= 1;i--)propagate(i);
    }

    public void update(int pos, int x)
    {
        st[H+pos] = x;
        for(int i = (H+pos)>>>1;i >= 1;i >>>= 1)propagate(i);
    }

    private void propagate(int i)
    {
        st[i] = Math.min(st[2*i], st[2*i+1]);
    }

    public int min(int l, int r){ return l >= r ? 0 : min(l, r, 0, H, 1);}

    private int min(int l, int r, int cl, int cr, int cur)
    {
        if(l <= cl && cr <= r){
            return st[cur];
        }else{
            int mid = cl+cr>>>1;
            int ret = Integer.MAX_VALUE;
            if(cl < r && l < mid){
                ret = Math.min(ret, min(l, r, cl, mid, 2*cur));
            }
            if(mid < r && l < cr){
                ret = Math.min(ret, min(l, r, mid, cr, 2*cur+1));
            }
            return ret;
        }
    }

    public int firstle(int l, int v) {
        int cur = H+l;
        while(true){
            if(st[cur] <= v){
                if(cur < H){
                    cur = 2*cur;
                }else{
                    return cur-H;
                }
            }else{
                cur++;
                if((cur&cur-1) == 0)return -1;
                if((cur&1)==0)cur>>>=1;
            }
        }
    }

    public int lastle(int l, int v) {
        int cur = H+l;
        while(true){
            if(st[cur] <= v){
                if(cur < H){
                    cur = 2*cur+1;
                }else{
                    return cur-H;
                }
            }else{
                if((cur&cur-1) == 0)return -1;
                cur--;
                if((cur&1)==1)cur>>>=1;
            }
        }
    }
}

public static void main(String[] args) throws Exception
{
    long S = System.currentTimeMillis();
    is = INPUT.isEmpty() ? System.in : new ByteArrayInputStream(INPUT.getBytes());
    out = new PrintWriter(System.out);

    solve();
    out.flush();
    long G = System.currentTimeMillis();
    tr(G-S+"ms");
}

private static boolean eof()
{
    if(lenbuf == -1)return true;
    int lptr = ptrbuf;
    while(lptr < lenbuf)if(!isSpaceChar(inbuf[lptr++]))return false;

    try {
        is.mark(1000);
        while(true){
            int b = is.read();
            if(b == -1){
                is.reset();
                return true;
            }else if(!isSpaceChar(b)){
                is.reset();
                return false;
            }
        }
    } catch (IOException e) {
        return true;
    }
}

private static byte[] inbuf = new byte[1024];
static int lenbuf = 0, ptrbuf = 0;

private static int readByte()
{
    if(lenbuf == -1)throw new InputMismatchException();
    if(ptrbuf >= lenbuf){
        ptrbuf = 0;
        try { lenbuf = is.read(inbuf); } catch (IOException e) { throw new InputMismatchException(); }
        if(lenbuf <= 0)return -1;
    }
    return inbuf[ptrbuf++];
}

private static boolean isSpaceChar(int c) { return !(c >= 33 && c <= 126); }
private static int skip() { int b; while((b = readByte()) != -1 && isSpaceChar(b)); return b; }

private static double nd() { return Double.parseDouble(ns()); }
private static char nc() { return (char)skip(); }

private static String ns()
{
    int b = skip();
    StringBuilder sb = new StringBuilder();
    while(!(isSpaceChar(b))){ // when nextLine, (isSpaceChar(b) && b != ' ')
        sb.appendCodePoint(b);
        b = readByte();
    }
    return sb.toString();
}

private static char[] ns(int n)
{
    char[] buf = new char[n];
    int b = skip(), p = 0;
    while(p < n && !(isSpaceChar(b))){
        buf[p++] = (char)b;
        b = readByte();
    }
    return n == p ? buf : Arrays.copyOf(buf, p);
}

private static char[][] nm(int n, int m)
{
    char[][] map = new char[n][];
    for(int i = 0;i < n;i++)map[i] = ns(m);
    return map;
}

private static int[] na(int n)
{
    int[] a = new int[n];
    for(int i = 0;i < n;i++)a[i] = ni();
    return a;
}

private static int ni()
{
    int num = 0, b;
    boolean minus = false;
    while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
    if(b == '-'){
        minus = true;
        b = readByte();
    }

    while(true){
        if(b >= '0' && b <= '9'){
            num = num * 10 + (b - '0');
        }else{
            return minus ? -num : num;
        }
        b = readByte();
    }
}

private static long nl()
{
    long num = 0;
    int b;
    boolean minus = false;
    while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
    if(b == '-'){
        minus = true;
        b = readByte();
    }

    while(true){
        if(b >= '0' && b <= '9'){
            num = num * 10 + (b - '0');
        }else{
            return minus ? -num : num;
        }
        b = readByte();
    }
}

private static void tr(Object... o) { if(INPUT.length() != 0)System.out.println(Arrays.deepToString(o)); }

}

any editorial for this question?