#include <iostream>
#include <cstdio>
#include <cmath>
#include <cstring>
#include <algorithm>
#include <cstdlib>
#include <string>
#include <queue>
#include <map>
#include <stack>
#include <list>
#include <set>
#include <unordered_set>
#include <deque>
#include <vector>
#include <ctime>
#include <cctype>
#include <ctime>

using namespace std;
#define ll long long
#define INF 0x3f
#define ls(x) (x << 1)
#define rs(x) (x << 1 | 1)
#define md(x) ((tr[x].l + tr[x].r)/2)
#define lowbit(x) ((x) & (-x))
typedef pair<int, int> PII;

ll gcd(ll a, ll b){ if (!b) return a; else return gcd(b, a % b);}
ll ksm(ll a, ll b, ll mod){ll ans = 1;while(b>0){if(b&1)ans = (ans * a) % mod; b>>=1 ;a = (a * a) % mod;}return ans;}

//---------------------------------------------------//

const int mod = 1e9+7;
const int Count = 10;
const int inf = 0x3f3f3f3f;
const int maxn = 1e6+5; 
const double pi = acos(-1);
const double eps = 1e-6;

//_____________________________________________________//
struct Node{
    int to, next;
}edge[maxn << 1];
int head[maxn], cnt;
void add(int u, int v){
    edge[++cnt].to = v;
    edge[cnt].next = head[u];
    head[u] = cnt;
}
struct node{
    int l, r;
    PII mx;
}tr[maxn * 4];
int a[maxn];
void pushup(int p){
    tr[p].mx = max(tr[ls(p)].mx, tr[rs(p)].mx);
}
void build(int p, int l, int r){
    tr[p].l = l;
    tr[p].r = r;
    if(l == r){
        tr[p].mx = {a[l], l};
        return;
    }
    int mid = md(p);
    build(ls(p), l, mid);
    build(rs(p), mid + 1, r);
    pushup(p);
}
PII query(int p, int l, int r){
    if(tr[p].l >= l && tr[p].r <= r) return tr[p].mx;
    int mid = md(p);
    PII tmp = {0, 0};
    if(l <= mid) tmp = max(tmp, query(ls(p), l, r));
    if(r > mid) tmp = max(tmp, query(rs(p), l, r));
    return tmp;
}
int ans = 0;
void dfs(PII now, int l, int r, int deep){// 当前数字,当前数字所继承区间
    // cout<<"!"<<now.first<<" "<<deep<<endl;
    if(l == r) return;
    if(now.second == l){
        PII ri = query(1, now.second+1, r);
        add(now.second, ri.second);
        add(ri.second, now.second);
        dfs(ri, now.second + 1, r, deep + 1);
    }else if(now.second == r){
        PII le = query(1, l, now.second-1);
        add(now.second, le.second);
        add(le.second, now.second);
        dfs(le, l, now.second - 1, deep + 1);
    }else{
        PII le = query(1, l, now.second-1);
        PII ri = query(1, now.second+1, r);
        add(now.second, ri.second);
        add(ri.second, now.second);
        add(now.second, le.second);
        add(le.second, now.second);
        // if(le > ri) {
            dfs(le, l, now.second - 1, deep+1);
            dfs(ri, now.second + 1, r, deep+1);
        // }else{
        //     dfs(ri, now.second + 1, r, deep+1);
        //     dfs(le, l, now.second - 1, deep+1);
        // }
    }
}
int deep[maxn];
int bfs(int st){
    queue<int> q;
    q.push(st);
    memset(deep, 0, sizeof(deep)); 
    deep[st] = 1;
    int now;
    while(!q.empty()){
        now = q.front();
        q.pop();
        for(int i = head[now];i;i = edge[i].next){
            int to = edge[i].to;
            if(deep[to] == 0){
                deep[to] = deep[now] + 1;
                q.push(to);
            }
        }
    }
    return now;
}
int id[maxn];
void init(int n){
    for(int i = 1;i <= n;i++) id[i] = i;
}
int find(int p){
    if(p == id[p]) return p;
    return id[p] = find(id[p]);
}
int flag[maxn];
queue<int> q;
int ed;
int lca[maxn];
void dfs_lca(int now, int fa){
    flag[now] = 1;
    for(int i = head[now];i;i = edge[i].next){
        int to = edge[i].to;
        if(to == fa) continue;
        dfs_lca(to, now);
        id[to] = now;
    }
    if(flag[ed]){
        while(!q.empty()){
            int tmp = q.front();
            q.pop();
            lca[tmp] = find(tmp);
        }
        lca[now] = find(ed);
    }else{
        q.push(now);
    }
}
void solve(void){
    int n;
    scanf("%d", &n);
    for(int i = 1;i <= n;i++) scanf("%d", &a[i]);
    init(n);
    build(1, 1, n);
    PII stt = query(1, 1, n);
    dfs(stt, 1, n, 1);
    int st = stt.second;
    ed = bfs(st);
    dfs_lca(st, 0);
    int ans = 0;
    for(int i = 1;i <= n;i++){
        ans = max(ans, deep[i] + deep[ed] - deep[lca[i]]);
    }
    printf("%d\n", ans-1);
}
signed main(void){ 

#ifdef _DEBUG
    freopen("in.in","r",stdin);
    freopen("out.out","w",stdout);
#endif

    int t = 1;
    // scanf("%d", &t);
    while(t--){
        solve();
    }

    return 0;
}