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<stdio.h>
#include<vector>
#include<algorithm>
using namespace std;
int dat[202020];
int main()
{
	int num;
	scanf("%d", &num);
	vector<int>v;
	for (int i = 0; i < num; i++)
	{
		int z;
		scanf("%d", &z);
		z--;
		v.push_back(z);
		int low = lower_bound(v.begin(), v.end(), -z) - v.begin();
		dat[z] = low;
		if (low == v.size())v.push_back(-z);
		else v[low] = -z;
	}
	int ans = 0, bef = -1;
	for (int i = num - 1; i >= 0; i--)
	{
		if (bef == -1)
		{
			if (dat[i] > 0)ans++, bef = i + 1;
		}
		else
		{
			int a = dat[i], b = dat[i + 1], c = dat[bef];
			bool f;
			if (a == b)f = false;
			else if (a == c)f = true;
			else if (int(a < b) + int(b < c) + int(c < a) == 2)f = false;
			else f = true;
			if (f)ans++, bef = i + 1;
		}
	}
	printf("%d\n", ans);
}