Problem: Takahashi loves sorting.

He has a permutation (p_1,p_2,...,p_N) of the integers from 1 through N. Now, he will repeat the following operation until the permutation becomes (1,2,...,N):

* First, we will define high and low elements in the permutation, as follows. The i-th element in the permutation is high if the maximum element between the 1-st and i-th elements, inclusive, is the i-th element itself, and otherwise the i-th element is low.
* Then, let a_1,a_2,...,a_k be the values of the high elements, and b_1,b_2,...,b_{N-k} be the values of the low elements in the current permutation, in the order they appear in it.
* Lastly, rearrange the permutation into (b_1,b_2,...,b_{N-k},a_1,a_2,...,a_k).



How many operations are necessary until the permutation is sorted?

Constraints

* 1 ≤ N ≤ 2×10^5
* (p_1,p_2,...,p_N) is a permutation of the integers from 1 through N.

Input

Input is given from Standard Input in the following format:


N
p_1 p_2 ... p_N


Output

Print the number of operations that are necessary until the permutation is sorted.

Examples

Input

5
3 5 1 2 4


Output

3


Input

5
5 4 3 2 1


Output

4


Input

10
2 10 5 7 3 6 4 9 8 1


Output

6

Solution (in CPP):

Solution:
#include<iostream>
using namespace std;
int n,p[1<<18],q[1<<18],t[1<<18],f[1<<18];
bool circle(int a,int b,int c){return q[a]<q[b]&&q[b]<q[c]||q[b]<q[c]&&q[c]<q[a]||q[c]<q[a]&&q[a]<q[b];}
int main()
{
	cin>>n;
	for(int i=0;i<n;i++)
	{
		cin>>p[i];
		q[p[i]]=i;
	}
	f[n]=n;
	for(int i=n;--i;)
	{
		if(t[i+1])
		{
			if(circle(f[i+1],i,i+1))
			{
				t[i]=t[i+1],f[i]=f[i+1];
			}
			else
			{
				t[i]=t[i+1]+1,f[i]=i+1;
			}
		}
		else
		{
			if(q[i]<q[i+1])
			{
				t[i]=0,f[i]=i;
			}
			else
			{
				t[i]=1,f[i]=i+1;
			}
		}
	}
	cout<<t[1]<<endl;
}