#if not _GLIBCXX_DEBUG
#define NDEBUG 1
#endif
#include<bits/stdc++.h>

struct RMQ{
	// use std::max
	using P=std::pair<int,int>;
	std::vector<std::vector<P>> j;
	RMQ(std::vector<int> const& v){
		std::vector<P> a(v.size());
		for(int i=0;i<int(v.size());i++) a[i]={v[i],i};
		j.push_back(std::move(a));

		for(int step=1;step<int(j.back().size());step*=2){
			std::vector<P> b(j.back().begin()+step,j.back().end());
			for(int i=0;i<int(b.size());i++) b[i]=std::max(b[i],j.back()[i]);
			j.push_back(std::move(b));
		}
	}
	P operator()(int l,int r)const{
		int layer=__builtin_clz(r-l)^31;
		return std::max(j[layer][l],j[layer][r-(1<<layer)]);
	}
};

int main(){
	std::ios::sync_with_stdio(0);std::cin.tie(0);
	int n;std::cin>>n;
	std::vector<int> h(n);for(auto& x:h) std::cin>>x;

	// construct the tree
	// can't remember how to do O(n)
	// just use rmq
	RMQ rmq(h);

	std::vector<int> parOf(n),depth(n);
	std::vector<int> order; order.reserve(n); // some postorder.
	std::vector<std::vector<int>> ad(n);

	auto const build=[&](auto build,int l,int r,int par)->void{
		if(l==r) return;
		auto [_,m]=rmq(l,r);
		parOf[m]=par;
		if(par>=0){
			depth[m]=depth[par]+1;
			ad[par].push_back(m);
		}
		build(build,l,m,m);
		build(build,m+1,r,m);
		order.push_back(m);
	};
	build(build,0,n,-1);

	auto [_,root]=rmq(0,n);
	assert(order.back()==root);

	// then
	std::vector<int> maxBelowDepth(n);
	for(auto x:order)
		if(parOf[x]>=0)
			maxBelowDepth[parOf[x]]=std::max(maxBelowDepth[parOf[x]], maxBelowDepth[x]+1);

	// then
	int re=maxBelowDepth[root];
	for(auto x:order)
		if(ad[x].size()==2)
			re=std::max(re,
					depth[x]+
					maxBelowDepth[ad[x][0]]+1+
					maxBelowDepth[ad[x][1]]+1
					);

	std::cout<<re<<'\n';


}