/*
TASK:psort
LANG:C++
*/

#include <cstdlib>
#include <iostream>
#include <fstream>
#include <math.h>
using namespace std;

int n;
int *pos;
int *nums;

// returns:
// 0 - when should not move;
// 1 - when should move after lesser
// 2 - when should move before greater
int shouldmove( int m );

// w - the position, this should assume, according to shouldmove
// return: true if m was moved, false otherwise
bool move( int m, int w );

int main() {
#ifdef MFIN
	ifstream in( "psort.inp" );
#else
	istream& in = cin;
#endif

	in >> n;
	pos = new int[n];
	nums = new int[n];
	int i, j, k;
	for ( i = 0; i < n; ++i ) {
		in >> k;
		pos[k-1] = i;
		nums[i] = k-1;
	}
	if ( n == 2 ) {
		if ( pos[0] == 0 )
			cout << 0 << endl;
		else
			cout << 1 << endl;
		delete[] pos;
		delete[] nums;
		return 0;
	}

	int steps = 0;
	i = 0;
	bool cont;
	int sm;
	do {
		cont = false;
		j = 0;
		sm = shouldmove( nums[i] );
		while ( sm == 0 && j < n ) {
			++j;
			++i;
			if ( i == n ) i = 0;
			sm = shouldmove( nums[i] );
		}
		if ( sm != 0 ) {
			if ( move( nums[i], sm ) ) {
				++steps;
				cont = true;
			}
			else {
				++i;
				if ( i == n ) i = 0;
			}
		}
		/*else {
			++i;
			if ( i == n ) i = 0;
		}*/

		// nothing requires more than n-1 steps
		if ( steps == n-1 ) break;
	} while( cont );

	cout << steps << endl;

#ifdef MFIN
	in.close();
#endif
	delete[] pos;
	delete[] nums;
	return 0;
}

// returns:
// 0 - when should not move;
// 1 - when should move after lesser
// 2 - when should move before greater
int shouldmove( int m ) {
	if ( pos[m] == m ) return 0;
	// a few borderline cases
	if ( m == 0 ) {
		if ( pos[0] == pos[1]-1 ) return 0;

		// 0 is after 1
		if ( pos[0] > pos[1] )
			return 2;

		return 0;
	}
	if ( m == n-1 ) {
		if ( pos[m-1] == pos[m]-1 ) return 0;

		// m is before m-1
		if ( pos[m] < pos[m-1] )
			return 1;

		return 0;
	}
	// lesser diff and greater diff
	int l, g;

	// ldiff
	if ( pos[m] < pos[m-1] )
		l = abs( m - pos[m-1] );
	else
		l = abs( m - pos[m-1]-1 );

	// gdiff
	if ( pos[m] < pos[m+1] )
		g = abs( m - pos[m+1]+1 );
	else
		g = abs( m - pos[m+1] );

	//if ( l != 0 && l == g ) return 0;
	if ( l>g ) return 2;
	return 1;
}


// 0 - when should not move;
// 1 - when should move after lesser
// 2 - when should move before greater
bool move( int m, int w ) {
	if ( w == 1 ) {
		if ( pos[m-1]+1 == pos[m] ) return false;
		
		int i;
		int s, e;
		if (  pos[m] < pos[m-1] ) {
			s = pos[m];
			e = pos[m-1];
			pos[m] = pos[m-1];
			for ( i = s; i < e; ++i ) {
				nums[i] = nums[i+1];
				--pos[ nums[i] ];
			}
			nums[i] = m;
		}
		else {
			s = pos[m-1] + 1;
			e = pos[m];
			for ( i = e; i > s; --i ) {
				nums[i] = nums[i-1];
				++pos[ nums[i] ];
			}
			nums[i] = m;
			pos[m] = s;
		}
		
		return true;
	}
	if ( w == 2 ) {
		if ( pos[m+1]-1 == pos[m] ) return false;
		
		int i;
		int s, e;
		if ( pos[m] > pos[m+1] ) {
			s = pos[m];
			e = pos[m+1]-1;
			for ( i = s; i > e; --i ) {
				nums[i] = nums[i-1];
				++pos[ nums[i] ];
			}
			pos[m] = e;
			nums[i] = m;
		}
		else {
			s = pos[m];
			e = pos[m+1]-1;
			pos[m] = pos[m+1]-1;
			for ( i = s; i < e; ++i ) {
				nums[i] = nums[i+1];
				--pos[ nums[i] ];
			}
			nums[i] = m;
		}

		return true;
	}

	return false;
}
