Problem: 2052A - Adrenaline Rush
Language: C++17 (GCC 7-32)


Submission (verdict: Wrong answer on test 4):
	#include<bits/stdc++.h>
		using namespace std ;
		typedef long long ll ;
			 
		typedef vector<long long> vll ;
		typedef pair<long long , long long> pll ;
		typedef map<long long , long long> mpll ;
			 
		#define pb push_back
		#define FOR(i,n) for(ll i = 0 ; i < n ; i++)
		#define all(x) (x).begin(),(x).end() 
			 
			 
		void print_vec(vll v){
			for(auto iter : v){
				cout << iter << " " ;
				}
			cout << endl ;
		}
		ll maxll(ll val1 ,ll val2){
					if(val1>val2){
						return val1 ;
					}
	 
					else{
						return val2 ;
					}
				}
				ll minll(ll val1 ,ll val2){
					if(val1<val2){
						return val1 ;
					}
					else{
						return val2 ;
					}
				}
				
			 
				vll input_vec(ll n){
					vll vec(n) ;
					FOR(i,n){
						cin >> vec[i] ;
					}
					return vec ;
				}
			 
	// 			long long gcd(ll a , ll b){
	// 				if(a%b == 0){ // a is the dividend in this case 
	// 					return b ;
	// 				}
	// 				return gcd(b,a%b) ;
	// 			}
	// 			long long lcm(ll a , ll b){
	// 				return (a*b)/gcd(a,b) ;
	// 			}
			 
			 
	// 			// Seive Algorithms
	// 			const int N = 1e7 + 7 ;
	// 			vector<bool> isPrime(N,1) ;
	// 			vector<ll> hp(N) ;
	// 			vector<ll> lp(N,0) ;
			 
	// 			void SeiveAlgo(){
	// 				isPrime[0] = isPrime[1] = 0 ;
	// 				for(int i = 2 ; i*i <= N ;i++){
	// 					if(isPrime[i] == true){
	// 						lp[i] = i ;
	// 						for(int j = i*i ; j <= N ; j += i){
	// 							isPrime[j] = false ;
	// 							hp[j] = i ;
	// 							if(lp[j] == 0){
	// 								lp[j] = i ;
	// 							}
	// 						}
	// 					}
	// 				}
							
	// 			}
			 
				
				
			 
					
			 
					
				
		 
			
				
	// 			long long power(long long a, long long b , long long mod)
	// 	{
	// 	    long long result = 1;
	// 	    while (b) {
	// 	        if (b & 1)
	// 	            result = (result * a) % mod;
	// 	        a = (a * a) % mod;
	// 	        b >>= 1;
	// 	    }
	// 	    return result;
	// 	}
	 
		
	// ll modInverse(ll A, ll M)
	// {
	//     return power(A, M - 2, M);
	// }
	 
	// ll cal_N_C_R(ll n , ll k , ll p){
	// 	ll n_fact = 1 ;
	// 	for(ll i = 1 ; i <= n ; i++){
	// 		n_fact = ((n_fact%p) * (i%p))%p ;
	// 	}
	// 	ll k_fact = 1 ;
	// 	for(ll i = 1 ; i <= k ; i++){
	// 		k_fact = ((k_fact%p) * (i%p))%p ;
	// 	}
	// 	ll n_minus_k_fact = 1 ;
	// 	for(ll i = 1 ; i <= (n - k) ; i++){
	// 		n_minus_k_fact = ((n_minus_k_fact%p) * (i%p))%p ;
	// 	}
	 
	// 	k_fact = power(k_fact , p - 2 , p) ;
	// 	n_minus_k_fact = power(n_minus_k_fact , p - 2 , p) ;
	// 	ll ans = ((n_fact%p) * (k_fact%p))%p ;
	// 	ans = ((ans%p) * (n_minus_k_fact%p))%p ;
	 
	// 	return ans ;
	 
	// }
	 
	// vll N_C_R(ll n , ll p){
	// 	vll v ;
	 
	// 	ll n_fact = 1 ;
	// 	for(ll i = 1 ; i <= n ; i++){
	// 		v.pb(n_fact) ;
	// 		n_fact = ((n_fact%p) * (i%p))%p ;
	// 	}
	// 	v.pb(n_fact) ;
	// 	//print_vec(v) ;
	 
	// 	vll ncr ;
	// 	for(ll i = 0 ; i < v.size() ; i++){
	// 		ll n_fact = v[v.size() - 1] ;
	// 		//cout << n_fact << endl ;
	// 		ll r_fact = power(v[i] , p - 2 , p) ;
	// 		//cout << r_fact << endl ;
	// 		ll n_minus_r_fact = power(v[n - i] , p - 2 , p) ;
	// 		//cout << v[n - i] << endl ;
	// 		//cout << "yes" << endl ;
	 
	// 		ll ans = ((n_fact%p) * (r_fact%p))%p ;
	// 		ans = ((ans%p) * (n_minus_r_fact%p))%p ;
	 
	 
	// 		ncr.pb(ans) ;
	// 	}
	 
	// 	//print_vec(ncr) ;
	// 	return ncr ;
	// }
	 
	// ll cal_max_len(vector<ll> &v , ll index , ll dp[] , map<ll,vll> &mp){
	// 	if(index == v.size() - 1){
	// 		return dp[index] = 0 ;
	// 	}
	// 	else if(index >= v.size()){
	// 		return 0 ;
	// 	}
	// 	else if(dp[index] != -1){
	// 		return dp[index] ;
	// 	}
	// 	else{
	// 		ll take = -1 ;
	// 		ll count = 0 ;
	// 		for(auto it : mp[v[index]]){
	// 			if(it > index){
	// 				take = maxll(take , it - index + 1 + cal_max_len(v , it + 1 , dp , mp)) ;
						
	// 			}
	 
	// 		}
	// 		ll not_take = cal_max_len(v , index + 1 , dp , mp) ;
	// 		dp[index] = max(take , not_take) ;
	// 		return dp[index] ;
	// 	}
	// }

	// ll cal_children(vector<ll> adj[] , ll dp[] , ll index){
	// 	if(dp[index] != -1){
	// 		return dp[index] ;
	// 	}
	// 	else if(adj[index].size() == 0){
	// 		return dp[index] = 1 ;
	// 	}
	// 	else{
	// 		ll sum = 0 ;
	// 		for(auto it : adj[index]){
	// 			sum += cal_children(adj , dp , it) ;
	// 		}
	// 		return dp[index] = sum + 1 ;
	// 	}
	// }
		

	// pair<ll,ll> cal_cost(ll curr_num , ll target , map<pair<ll,ll> , pair<ll,ll>> &mp){
	// 	pair<ll,ll> P ;
	// 	P.first = curr_num ;
	// 	P.second = target ;
	// 	if(mp.find(P) != mp.end()){
	// 		return mp[P] ;
	// 	}
	// 	else if(curr_num > target){
	// 		pair<ll,ll> p1 = cal_cost(curr_num/2 + curr_num%2 , target , mp) ;
	// 		pair<ll,ll> p2 = cal_cost(curr_num - curr_num/2 - curr_num%2 , target , mp) ;
	// 		pair<ll,ll> p ;
	// 		p.first = 1 + p1.first + p2.first ;
	// 		p.second = minll(p1.second , p2.second) ;
	// 		return mp[P] = p ;
	// 	}
	// 	else{
	// 		pair<ll,ll> p ;
	// 		p.first = 0 ;
	// 		p.second = curr_num ;
	// 		return mp[P] = p ;
	// 	}
	// }


	// ll binary_search(vll &v , ll target){
	// 	ll lower_bound = 0 ;
	// 	ll upper_bound = v.size() - 1 ;

	// 	ll mid = (upper_bound - lower_bound) / 2 + lower_bound ;

	// 	while(upper_bound >= lower_bound){
	// 		mid = (upper_bound - lower_bound) / 2 + lower_bound ;

	// 		if(v[mid] > target){
	// 			upper_bound = mid - 1 ;
	// 			mid = mid - 1 ;
	// 		}
	// 		else if(v[mid] < target){
	// 			lower_bound = mid + 1 ;
	// 		}
	// 		else if(v[mid] == target){
	// 			return mid ;
	// 		}
			
	// 	}
	// 	return mid;
	// }


	// ll cal_ways(vll &v , ll index , ll x , vll &prefix_sums , ll dp[]){
	// 	if(index == v.size()){
	// 		return dp[index] = 0 ;
	// 	}
	// 	if(dp[index] != -1){
	// 		return dp[index] ;
	// 	}
	// 	ll target_sum ;
	// 	if(index == 0){
	// 		target_sum = x ;
	// 	}
	// 	else{
	// 		target_sum = x + prefix_sums[index - 1] ;
	// 	}
	// 	ll lower_bound = index ;
	// 	ll upper_bound = v.size() - 1 ;

	// 	// cout << lower_bound << upper_bound << endl ;
	// 	// cout << target_sum << endl ;

	// 	ll mid = (upper_bound - lower_bound) / 2 + lower_bound ;
	// 	while(lower_bound <= upper_bound){
	// 		mid = (upper_bound - lower_bound) / 2 + lower_bound ;
	// 		if(prefix_sums[mid] <= target_sum){
	// 			lower_bound = mid + 1 ;
	// 			mid = mid + 1 ;
	// 		}
	// 		else if(prefix_sums[mid] > target_sum){
	// 			upper_bound = mid - 1 ;
	// 		}

	// 	}
	// 	//cout << mid << endl ;
	// 	if(mid == v.size()){
	// 		return dp[index] = 0 ;
	// 	}
	// 	else{
	// 		dp[index] = 1 + cal_ways(v , mid + 1 , x , prefix_sums , dp) ;
	// 		return dp[index] ;
	// 	}
	// }

	// ll dfs_checker(vll &initial_perm , map<ll,set<ll>> &adj , ll node , ll ptr){

	// 	if(ptr == initial_perm.size()){
	// 		return ptr ;
	// 	}
	// 	else if(ptr == -1){
	// 		return -1 ;
	// 	}
	// 	while(true){
	// 		if(ptr == initial_perm.size()){
	// 			return ptr ;
	// 		}
	// 		if(adj[node].find(initial_perm[ptr]) != adj[node].end()){
	// 			adj[node].erase(*adj[node].find(initial_perm[ptr])) ;
	// 			//cout << "yes" << endl ;
	// 			ptr = dfs_checker(initial_perm , adj , initial_perm[ptr] , ptr+1) ;
	// 			//cout << ptr << endl ;
				
	// 		}
	// 		else if(adj[node].size() == 0){
	// 			return ptr ;
	// 		}
	// 		else{
	// 			return -1 ;
	// 		}
			
	// 	}
	// 	if(ptr == initial_perm.size()){
	// 		return ptr ;
	// 	}
	// 	else{
	// 		return ptr ;
	// 	}
	// }

	// void bfs(set<ll> adj[] , ll starting_node , ll vis[] , ll deg[]){
	// 	queue<ll> q ;
	// 	vll v ;
	// 	v.pb(starting_node) ;
	// 	q.push(starting_node) ;

	// 	vis[starting_node] = 1 ;

	// 	while(!q.empty()){
	// 		ll node = q.front() ;
	// 		q.pop() ;

	// 		for(auto it : adj[node]){
	// 			if(vis[it] == -1){
	// 				q.push(it) ;
	// 				vis[it] = 1 ;
	// 				v.pb(it) ;
	// 			}
	// 		}
	// 	}
	// }
	// ll func(vll &v , ll curr_s , ll curr_i , ll index , ll dp[]){

	// 	//cout << curr_s << " " << curr_i << " " << index << endl ;
	// 	if(index == v.size()){
	// 		return 0 ;
	// 	}
	// 	if(dp[curr_s] != -1){
	// 		return dp[curr_s] ;
	// 	}
	// 	if(v[index] == 0){
	// 		ll p = max(func(v , curr_s + 1 , curr_i , index+1 , dp) , func(v , curr_s , curr_i + 1 , index+1 , dp)) ;
	// 		//cout << p << endl ;
	// 		dp[curr_s] = p ;
	// 		return p ;
	// 	}
	// 	else if(v[index] > 0){
	// 		if(curr_s >= v[index]){
	// 			return 1 + func(v , curr_s , curr_i , index + 1 , dp);
	// 		}
	// 		else{
	// 			return 0 + func(v , curr_s , curr_i , index + 1 , dp);
	// 		}
	// 	}
	// 	else if(v[index] < 0){
	// 		if(curr_i >= abs(v[index])){

	// 			ll p = 1 + func(v , curr_s , curr_i , index + 1 , dp) ;
	// 			//cout << p << endl  ;
	// 			return p ;
	// 		}
	// 		else{
	// 			return 0 + func(v , curr_s , curr_i , index + 1 , dp);
	// 		}
	// 	}
	// 	return dp[curr_s] = func(v , curr_s , curr_i , index , dp) ;
	// }

	// ll func2(vll &v , ll curr_s , ll curr_i , ll index , ll dp[]){

	// 	//cout << curr_s << " " << curr_i << " " << index << endl ;
	// 	if(index == v.size()){
	// 		return 0 ;
	// 	}
	// 	if(dp[curr_i] != -1){
	// 		return dp[curr_i] ;
	// 	}
	// 	if(v[index] == 0){
	// 		ll p = max(func2(v , curr_s + 1 , curr_i , index+1 , dp) , func2(v , curr_s , curr_i + 1 , index+1 , dp)) ;
	// 		//cout << p << endl ;
	// 		dp[curr_i] = p ;
	// 		return p ;
	// 	}
	// 	else if(v[index] > 0){
	// 		if(curr_s >= v[index]){
	// 			return 1 + func2(v , curr_s , curr_i , index + 1 , dp);
	// 		}
	// 		else{
	// 			return 0 + func2(v , curr_s , curr_i , index + 1 , dp);
	// 		}
	// 	}
	// 	else if(v[index] < 0){
	// 		if(curr_i >= abs(v[index])){

	// 			ll p = 1 + func2(v , curr_s , curr_i , index + 1 , dp) ;
	// 			//cout << p << endl  ;
	// 			return p ;
	// 		}
	// 		else{
	// 			return 0 + func2(v , curr_s , curr_i , index + 1 , dp);
	// 		}
	// 	}
	// 	return dp[curr_i] = func2(v , curr_s , curr_i , index , dp) ;
	// }
	bool cmp2(pair<ll,ll>&p1 , pair<ll,ll>&p2){
		

					if(min(p1.first , p1.second) < min(p2.first , p2.second)){
						return true ;
					}
					else if(min(p1.first , p1.second) == min(p2.first , p2.second)){
						return max(p1.first , p1.second) <= max(p2.first , p2.second) ;
					}
					return false ;
				}


// ll cal_min_sum(ll x , ll y , ll arr[][] , ll dp[][] , ll shifted){
// 	if(dp[i][j] != -1){
// 		return dp[i][j] ;
// 	}
// 	else if((j == 0) and (i == 0)){

// 	}
// }
void solve(ll P) {
	
ll n ;
cin >> n ;

vll v = input_vec(n) ;
reverse(all(v)) ;
vll V = v ;

map<ll,ll> mp ;
vll init ;
for(ll i = 0 ; i < n ; i++){
	init.pb(i+1) ;
	mp[v[i]] = i+1 ;
}

ll count = 0 ;
vector<pair<ll,ll>> vp ;

for(ll i = 0 ; i < n ; i++){
	for(ll j = i + 1; j < n ; j++){
		if(v[i] > v[j]){
			ll temp = v[i] ;
			v[i] = v[j] ;
			v[j] = temp ;

			pair<ll,ll> p ;
			p.first = v[i] ;
			p.second = v[j] ;

			vp.pb(p) ;

			count++ ;
		}
	}
}

cout << count + ((n-1)*(n))/2 << endl ;

for(auto it : vp){
	cout << it.second << " " << it.first << endl ;
}

// print_vec(V) ;

for(ll i = 0 ; i < n ; i++){
	for(ll j = i+1 ; j < n ; j++){
		cout << V[j] << " " << V[i] << endl ;
	}
}

}
	 	
	 
	 	 
				int main(){
					// SeiveAlgo() ;
							
					// lp[1] = 1 ;
					ios_base::sync_with_stdio(false);
					cin.tie(NULL) ;
			 
					ll t = 1;
					
						
					ll p = 1 ;
	 
					while(t--){
			 
						solve(p);
						p++;
						
					}
				}