// Not afraid to dark.

#include <bits/stdc++.h>
using namespace std;

clock_t start_time, end_time;
#define GET_START start_time = clock ();
#define GET_END end_time = clock (); fprintf (stderr, "TIME COSSEMED : %0.3lf\n", 1.0 * (end_time - start_time) / CLOCKS_PER_SEC);
#define inline __inline__ __attribute__ ((always_inline))

namespace io {
    int read_pos, read_dt; char read_char;
    inline int read (int &p = read_pos){
        p = 0, read_dt = 1; read_char = getchar ();
        while (! isdigit (read_char)){
            if (read_char == '-')
                read_dt = - 1;
            read_char = getchar ();
        }
        while (isdigit (read_char)){
            p = (p << 1) + (p << 3) + read_char - 48;
            read_char = getchar ();
        }
        return p = p * read_dt;
    }
    int write_sta[65], write_top;
    inline void write (int x){
        if (x < 0)
            putchar ('-'), x = - x;
        write_top = 0;
        do
            write_sta[write_top ++] = x % 10, x /= 10;
        while (x);
        while (write_top)
            putchar (write_sta[-- write_top] + 48);
    }
    // int llen;
    // inline int get_string (char c[], int &len = llen){
    //     len = 0;
    //     read_char = getchar ();
    //     while (read_char == ' ' || read_char == '\n' || read_char == '\r')
    //         read_char = getchar ();
    //     while (read_char != ' ' && read_char != '\n' && read_char != '\r'){
    //         c[++ len] = read_char;
    //         read_char = getchar ();
    //     }
    //     return len;
    // }
}

const int N = 1e6;
int n, a[N + 5];
// char c[N + 5];
int pre[N + 5], suf[N + 5];
int top, sta[N + 5];

namespace SGT {
    #define lson(p) ((p) << 1)
    #define rson(p) ((p) << 1 | 1)
    const int S = N << 2;
    int tag[S + 5], mx[S + 5], lt[S + 5], rt[S + 5], la[S + 5], ra[S + 5];
    bool flg[S + 5];
    auto put_tag = [] (int p, int t){ tag[p] += t; mx[p] += t; la[p] += t; ra[p] += t; };
    auto push_tag = [] (int p){
        if (lt[p] != rt[p])
            put_tag (lson (p), tag[p]), put_tag (rson (p), tag[p]);
        tag[p] = 0;
    };
    auto push_up = [] (int p){
        mx[p] = tag[p];
        flg[p] = (lt[p] == rt[p] || (flg[lson (p)] && flg[rson (p)] && (ra[lson (p)] <= la[rson (p)] + 1 || lt[rson (p)] > top)));
        if (lt[p] != rt[p])
            la[p] = la[lson (p)] + tag[p],
            ra[p] = ra[rson (p)] + tag[p],
            mx[p] += max (mx[lson (p)], mx[rson (p)]);
        else
            la[p] = ra[p] = tag[p];
    };
    void Build (int p = 1, int l = 1, int r = n){
        tag[p] = mx[p] = la[p] = ra[p] = 0, lt[p] = l, rt[p] = r;
        flg[p] = true;
        if (l == r)
            return ;
        int mid = (l + r) >> 1;
        Build (lson (p), l, mid);
        Build (rson (p), mid + 1, r);
        push_up (p);
    }
    void Add (int l, int r, int t, int p = 1){
        if (l > r)
            return ;
        if (l <= lt[p] && rt[p] <= r){
            put_tag (p, t);
            return ;
        }
        int mid = (lt[p] + rt[p]) >> 1;
        if (l <= mid)
            Add (l, r, t, lson (p));
        if (r > mid)
            Add (l, r, t, rson (p));
        push_up (p);
    }
    inline int Last (){
        static int p, mid;
        p = 1;
        while (true){
            if (lt[p] == rt[p])
                return lt[p];
            mid = (lt[p] + rt[p]) >> 1;
            if (! flg[rson (p)])
                p = rson (p);
            else
            if (! (ra[lson (p)] <= la[rson (p)] + 1 || lt[rson (p)] > top))
                return mid + 1;
            else
                p = lson (p);
        }
    }
    inline int Query (int x){
        static int p, mid, res;
        if (x == 0)
            return 0;
        p = 1, res = 0;
        while (true){
            res += tag[p];
            if (lt[p] == rt[p])
                break;
            mid = (lt[p] + rt[p]) >> 1;
            if (x <= mid)
                p = lson (p);
            else
                p = rson (p);
        }
        return res;
    }
    inline void Erase (int x){
        static int p, mid;
        p = 1;
        while (true){
            push_tag (p);
            if (lt[p] == rt[p])
                break;
            mid = (lt[p] + rt[p]) >> 1;
            if (x <= mid)
                p = lson (p);
            else
                p = rson (p);
        }
        mx[p] = 0;
        while (true){
            push_up (p);
            if (p == 1)
                break;
            p >>= 1;
        }
    }
} using namespace SGT;

int idx, px[N + 5], sx[N + 5];
int pm[N + 5], sm[N + 5];
int pt[N + 5], st[N + 5], ton[N + 5];

auto imax = [] (const int i, const int j){
    return a[i] > a[j] ? i : j;
};

inline void ARKNIGHTS (){
    io::read (n);
    for (int i = 1;i <= n;++ i)
        io::read (a[i]), idx = (a[i] == n) ? i : idx;
    for (int i = 1;i <= n;++ i){
        px[i] = max (px[i - 1], a[i]);
        pm[i] = imax (pm[i - 1], i);
    }
    for (int i = n, las = 0;i >= 1;-- i){
        if (pm[i] == i)
            las = i;
        pm[i] = las;
    }
    sx[n + 1] = sm[n + 1] = 0;
    for (int i = n;i >= 1;-- i){
        sx[i] = max (sx[i + 1], a[i]);
        sm[i] = imax (sm[i + 1], i);
    }
    for (int i = 1, las = 0;i <= n;++ i){
        if (sm[i] == i)
            las = i;
        sm[i] = las;
    }
    // io::get_string (c);
    Build ();
    top = 0;
    for (int i = 1, x, p;i <= n;++ i){
        x = 0;
        while (top > 0 && sta[top] < a[i]){
            x = Query (top);
            Erase (top);
            -- top;
        }
        sta[++ top] = a[i];
        ton[i] = top;
        Add (top, top, x);
        p = Last ();
        Add (p, top, 1);
        pre[i] = mx[1];
        pt[i] = Query (ton[sm[i]]);
    }
    Build ();
    top = 0;
    suf[n + 1] = st[n + 1] = 0;
    for (int i = n, x, p;i >= 1;-- i){
        x = 0;
        while (top > 0 && sta[top] < a[i]){
            x = Query (top);
            Erase (top);
            -- top;
        }
        sta[++ top] = a[i];
        ton[i] = top;
        Add (top, top, x);
        p = Last ();
        Add (p, top, 1);
        suf[i] = mx[1];
        st[i] = Query (ton[pm[i]]);
    }
    suf[n + 1] = 0;
    int ans = max (pre[n], suf[1]);
    for (int i = 1;i < n;++ i){
        ans = max (ans, pre[i] + suf[i + 1]);
        // ans = max (ans, pre[i] + st[i + 1]);
    }
    io::write (ans - 1), putchar ('\n');
}

signed main (){
    GET_START

    for (int T = 1;T --;)
        ARKNIGHTS ();

    GET_END
    return 0;
}