Problem:
Score : 2400 points

Problem Statement

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.

Sample Input 1

5
3 5 1 2 4

Sample Output 1

3

The initial permutation is (3,5,1,2,4), and each operation changes it as follows:

In the first operation, the 1-st and 2-nd elements are high, and the 3-rd, 4-th and 5-th are low. The permutation becomes: (1,2,4,3,5).

In the second operation, the 1-st, 2-nd, 3-rd and 5-th elements are high, and the 4-th is low. The permutation becomes: (3,1,2,4,5).

In the third operation, the 1-st, 4-th and 5-th elements are high, and the 2-nd and 3-rd and 5-th are low. The permutation becomes: (1,2,3,4,5).

Sample Input 2

5
5 4 3 2 1

Sample Output 2

4

Sample Input 3

10
2 10 5 7 3 6 4 9 8 1

Sample Output 3

6

Solution in C (GCC 5.4.1) (judge verdict: Time Limit Exceeded)

#pragma GCC optimize(2)
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define eprintf(...) fprintf(stderr, __VA_ARGS__)

int Max(int a, int b) {return a > b ? a : b;}

#define maxn 200005

struct T {
	char mon;
	int val, mx, fst;
	int fix;
	int lson, rson;
} t[maxn];

int tot;

int new_node(int v) {
	int x = ++ tot;
	t[x].mon = 1;
	t[x].val = v; t[x].mx = v; t[x].fst = v;
	t[x].fix = rand();
	t[x].lson = t[x].rson = 0;
	return x;
}

void pushup0(int x) {
	t[x].fst = t[x].lson ? t[t[x].lson].fst : t[x].val;
	char mo = 1;
	t[x].mx = t[x].val;
	if (t[x].lson) {
		t[x].mx = Max(t[x].mx, t[t[x].lson].mx);
		mo &= t[t[x].lson].mon && t[t[x].lson].mx < t[x].val;
	}
	if (t[x].rson) {
		t[x].mx = Max(t[x].mx, t[t[x].rson].mx);
		mo &= t[t[x].rson].mon && t[x].val < t[t[x].rson].fst;
	}
	t[x].mon = mo;
}

void pushup1(int x) {
	t[x].mon = 1;
	t[x].fst = t[x].lson ? t[t[x].lson].fst : t[x].val;
	t[x].mx = t[x].rson ? t[t[x].rson].mx : t[x].val;
}

int merge0(int a, int b) {
	if (!a || !b) return a | b;
	if (t[a].fix < t[b].fix) {
		t[a].rson = merge0(t[a].rson, b);
		pushup0(a);
		return a;
	} else {
		t[b].lson = merge0(a, t[b].lson);
		pushup0(b);
		return b;
	}
}

int merge1(int a, int b) {
	if (!a || !b) return a | b;
	if (t[a].fix < t[b].fix) {
		t[a].rson = merge1(t[a].rson, b);
		pushup1(a);
		return a;
	} else {
		t[b].lson = merge1(a, t[b].lson);
		pushup1(b);
		return b;
	}
}

int split(int x, int v, int *a, int *b) {
	if (!x) {*a = *b = 0; return v;}
	if (t[x].mx < v) {*a = x; *b = 0; return v;}
	if (t[x].mon) {
		if (t[x].fst > v) {*a = 0; *b = x; return t[*b].mx;}
		if (t[x].val < v) {
			*a = x; split(t[x].rson, v, &t[*a].rson, b);
			pushup1(*a); return t[*b].mx;
		} else {
			*b = x; split(t[x].lson, v, a, &t[*b].lson);
			pushup1(*b); return t[*b].mx;
		}
	} else {
		int ls = t[x].lson, rs = t[x].rson;
		t[x].lson = t[x].rson = 0;
		pushup1(x);
		v = split(ls, v, a, b);
		if (t[x].val > v) *b = merge1(*b, x), v = t[x].val;
		else *a = merge0(*a, x);
		int c, d;
		v = split(rs, v, &c, &d);
		*a = merge0(*a, c); *b = merge1(*b, d);
		return v;
	}
}

int rt;

int main() {
//	freopen("in", "r", stdin);
	srand(200);
	int n; scanf("%d", &n);
	for (int i = 1; i <= n; ++ i) {
		int p; scanf("%d", &p);
		rt = merge0(rt, new_node(p));
	}
	int ans = 0;
	while (!t[rt].mon) {
		++ ans;
		int a, b;
		split(rt, 0, &a, &b);
		rt = merge0(a, b);
//		printf("%d\n", ans);
	}
	printf("%d\n", ans);
//	eprintf("time used: %.3f\n", clock() * 1.0 / CLOCKS_PER_SEC);
	return 0;
}