#include <assert.h>
#include <ctype.h>
#include <limits.h>
#include <math.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char* readline();
char* ltrim(char*);
char* rtrim(char*);
char** split_string(char*);

int parse_int(char*);

void printf_arr(int* arr, int n){
    for (int i= 0; i<n; i++){
        printf("%d ", arr[i]);
    }
    printf("\n");
}


void swap(int* a, int* b, int* count){
    (*count ) ++;
    int temp = *a;
    *a = *b;
    *b = temp;
}

int insertionSort2(int n, int arr_count, int* arr, int* count) {
    for (int i = 1; i<arr_count; i++){
        int j = i;
        while (j-1 >= 0 && arr[j] < arr[j-1]){
            swap(&arr[j], &arr[j-1], count);
            j --;
        }
    }
    return *count;
}


int partition(int l, int r, int* arr, int* count){
    int pivot = arr[r];
    int i = l-1;
    for (int j = l; j<r; j++){
        if (arr[j] < pivot){
            i ++;
            swap(&arr[i], &arr[j], count);
        }
    }
    i ++;
    swap(&arr[i], &arr[r], count);
    return i;
}

int quicksort(int l, int r, int* arr, int* count){
    if (l < r){
        int idx = partition(l, r, arr, count);
        quicksort(l, idx-1, arr, count);
        quicksort(idx+1, r, arr, count);
    }
    return *count;
}


int main()
{
    int insertion_sort_count = 0;
    int quicksort_count = 0;
    int n = parse_int(ltrim(rtrim(readline())));

    char** arr_temp = split_string(rtrim(readline()));

    int* arr_1 = malloc(n * sizeof(int));
    int* arr_2 = malloc(n * sizeof(int));

    
    for (int i = 0; i < n; i++) {
        int arr_item = parse_int(*(arr_temp + i));

        *(arr_1 + i) = arr_item;
        *(arr_2 + i) = arr_item;

    }

    insertion_sort_count = insertionSort2(n, n, arr_1, &insertion_sort_count);
    quicksort_count = quicksort(0, n-1, arr_2, &quicksort_count);
    printf("%d\n", insertion_sort_count-quicksort_count);
    return 0;
}

char* readline() {
    size_t alloc_length = 1024;
    size_t data_length = 0;

    char* data = malloc(alloc_length);

    while (true) {
        char* cursor = data + data_length;
        char* line = fgets(cursor, alloc_length - data_length, stdin);

        if (!line) {
            break;
        }

        data_length += strlen(cursor);

        if (data_length < alloc_length - 1 || data[data_length - 1] == '\n') {
            break;
        }

        alloc_length <<= 1;

        data = realloc(data, alloc_length);

        if (!data) {
            data = '\0';

            break;
        }
    }

    if (data[data_length - 1] == '\n') {
        data[data_length - 1] = '\0';

        data = realloc(data, data_length);

        if (!data) {
            data = '\0';
        }
    } else {
        data = realloc(data, data_length + 1);

        if (!data) {
            data = '\0';
        } else {
            data[data_length] = '\0';
        }
    }

    return data;
}

char* ltrim(char* str) {
    if (!str) {
        return '\0';
    }

    if (!*str) {
        return str;
    }

    while (*str != '\0' && isspace(*str)) {
        str++;
    }

    return str;
}

char* rtrim(char* str) {
    if (!str) {
        return '\0';
    }

    if (!*str) {
        return str;
    }

    char* end = str + strlen(str) - 1;

    while (end >= str && isspace(*end)) {
        end--;
    }

    *(end + 1) = '\0';

    return str;
}

char** split_string(char* str) {
    char** splits = NULL;
    char* token = strtok(str, " ");

    int spaces = 0;

    while (token) {
        splits = realloc(splits, sizeof(char*) * ++spaces);

        if (!splits) {
            return splits;
        }

        splits[spaces - 1] = token;

        token = strtok(NULL, " ");
    }

    return splits;
}

int parse_int(char* str) {
    char* endptr;
    int value = strtol(str, &endptr, 10);

    if (endptr == str || *endptr != '\0') {
        exit(EXIT_FAILURE);
    }

    return value;
}

import java.util.Scanner;

public class CompareSorts {

    private static int quickSortSwaps = 0;

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int[] arrQuickSort = new int[n];
        int[] arrInsertionSort = new int[n];

        for (int i = 0; i < n; i++) {
            int num = scanner.nextInt();
            arrQuickSort[i] = num;
            arrInsertionSort[i] = num;
        }

        int insertionSortShifts = insertionSort(arrInsertionSort);
        quickSort(arrQuickSort, 0, n - 1);

        int result = insertionSortShifts - quickSortSwaps;
        System.out.println(result);

        scanner.close();
    }

    public static void quickSort(int[] arr, int low, int high) {
        if (low < high) {
            int pivotIndex = partition(arr, low, high);
            quickSort(arr, low, pivotIndex - 1);
            quickSort(arr, pivotIndex + 1, high);
        }
    }

    public static int partition(int[] arr, int low, int high) {
        int pivot = arr[high];
        int i = low - 1;

        for (int j = low; j < high; j++) {
            if (arr[j] < pivot) {
                i++;
                swap(arr, i, j);
            }
        }

        swap(arr, i + 1, high);
        return i + 1;
    }

    public static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
        quickSortSwaps++; // Increment the swap count
    }

    public static int insertionSort(int[] arr) {
        int shifts = 0;

        for (int i = 1; i < arr.length; i++) {
            int key = arr[i];
            int j = i - 1;

            while (j >= 0 && arr[j] > key) {
                arr[j + 1] = arr[j];
                j--;
                shifts++;
            }

            arr[j + 1] = key;
        }

        return shifts;
    }
}

def insertion_sort(arr)
    ops = 0
    i = 1
    while (i < arr.length)
        if arr[i] < arr[i - 1]
            value = arr[i]
            j = i-1
            while (j >= 0 && value < arr[j])
                arr[j+1] = arr[j]
                ops += 1
                j -= 1
            end
            arr[j+1] = value
        end
        i += 1
    end
    ops
end

def partition_lomuto(arr, lo, hi)
    pivot = arr[hi]
    i = lo - 1
    lo.upto(hi) do |j|
       if arr[j] <= pivot
            i += 1
            arr[i], arr[j] = arr[j], arr[i]
       end
    end
   [i, (i - lo + 1)]
end

def quicksort(arr, lo, hi)
    return 0 unless lo >= 0 && hi >= 0 && lo < hi
    pivot, ops_part= partition_lomuto(arr, lo, hi)
    quicksort(arr, lo, pivot - 1) + quicksort(arr, pivot + 1, hi) + ops_part
end

_n = gets.strip.to_i
arr = gets.rstrip.split.map(&:to_i)
puts insertion_sort(arr.clone) - quicksort(arr, 0, arr.length - 1)

# Enter your code here. Read input from STDIN. Print output to STDOUT
import copy
# Insertion sort Swaps
def insertion_sort(arr):
    n = len(arr)
    counter_for_swaps = 0
    for i in range(1, n):
        val = arr[i]
        j = i-1

        while(j >= 0 and arr[j] > val):
            arr[j+1] = arr[j]
            counter_for_swaps += 1
            j -= 1

        arr[j+1] = val
    # print(*arr)
    return counter_for_swaps

class Insertion:
    def __init__(self):
        self.count=0
    def insertionsort(self,a):
        for i in range(1,len(a)):
            key=a[i]
            j=i-1
            while j>=0 and a[j]>key:
                self.count+=1
                a[j+1]=a[j]
                j-=1
            a[j+1]=key
        return self.count

class QuickSort:
    def __init__(self):
        self.count=0
    def swap(self,b,c,d):
        temp=b[c]
        b[c]=b[d]
        b[d]=temp
        return b
    def partition(self,a,s,e):
        pivot=e
        pindex=s
        for i in range(s,e):
            if a[i]<=a[pivot]:
                self.swap(a,i,pindex)
                self.count+=1
                pindex+=1
        self.count+=1
        self.swap(a,pindex,pivot)
        return pindex
    def quicksort(self,a,s,e):
        if s<e:
            pIndex=self.partition(a,s,e)
            self.quicksort(a, s, pIndex-1)
            self.quicksort(a, pIndex+1, e)
        return self.count
    
if __name__ == '__main__':
    N = int(input())
    original = list(map(int,input().split()))
    duplicate = copy.deepcopy(original)

    insertion_counter_for_swaps = insertion_sort(original)
    # print(insertion_counter_for_swaps)

    # Quicky
    quicksort=QuickSort()
    start = 0
    end = N -1
    quicksort_counter_for_swaps = quicksort.quicksort(duplicate, start, end)
    print(insertion_counter_for_swaps - quicksort_counter_for_swaps)

# Enter your code here. Read input from STDIN. Print output to STDOUT

def runningTimeIn(arr):
    count = 0
    for i in range(1,len(arr)):
        j = i-1
        key = arr[i]
        while (j>=0) and (arr[j]>key):
            arr[j+1]=arr[j]
            j -= 1
            count += 1
        arr[j+1]=key
    return count

def partition(arr,low,high,swap):
    i = ( low-1 )         
    pivot = arr[high] 
    #swaps = 0
    for j in range(low , high): 
        if   arr[j] <= pivot: 
            i = i+1 
            arr[i],arr[j] = arr[j],arr[i]
            swap += 1
  
    arr[i+1],arr[high] = arr[high],arr[i+1] 
    swap += 1
    return i+1,swap 
  
def runningTimeQ(arr,low,high,swap=0): 
    pi = 0
    if low < high:
        pi,swap = partition(arr,low,high,swap) 
        #print (' '.join(map(str, arr)))
        swap = runningTimeQ(arr, low, pi-1,swap) 
        swap = runningTimeQ(arr, pi+1, high,swap) 
    return swap

if __name__ == '__main__':
    n = int(input())

    arr = list(map(int, input().rstrip().split()))

    arrCopy = []
    arrCopy.extend(arr)
    
    qRun = runningTimeQ(arr,0,n-1)
    
    inRun = runningTimeIn(arrCopy)
    
    result = inRun - qRun 

    print(result)