A Ministry for Defense sent a general to inspect the Super Secret Military Squad under the command of the Colonel SuperDuper. Having learned the news, the colonel ordered to all n squad soldiers to line up on the parade ground.

By the military charter the soldiers should stand in the order of non-increasing of their height. But as there's virtually no time to do that, the soldiers lined up in the arbitrary order. However, the general is rather short-sighted and he thinks that the soldiers lined up correctly if the first soldier in the line has the maximum height and the last soldier has the minimum height. Please note that the way other solders are positioned does not matter, including the case when there are several soldiers whose height is maximum or minimum. Only the heights of the first and the last soldier are important.

For example, the general considers the sequence of heights (4, 3, 4, 2, 1, 1) correct and the sequence (4, 3, 1, 2, 2) wrong.

Within one second the colonel can swap any two neighboring soldiers. Help him count the minimum time needed to form a line-up which the general will consider correct.

Input

The first input line contains the only integer n (2 ≤ n ≤ 100) which represents the number of soldiers in the line. The second line contains integers a1, a2, ..., an (1 ≤ ai ≤ 100) the values of the soldiers' heights in the order of soldiers' heights' increasing in the order from the beginning of the line to its end. The numbers are space-separated. Numbers a1, a2, ..., an are not necessarily different.

Output

Print the only integer — the minimum number of seconds the colonel will need to form a line-up the general will like.

Examples

Input

4
33 44 11 22


Output

2


Input

7
10 10 58 31 63 40 76


Output

10

Note

In the first sample the colonel will need to swap the first and second soldier and then the third and fourth soldier. That will take 2 seconds. The resulting position of the soldiers is (44, 33, 22, 11).

In the second sample the colonel may swap the soldiers in the following sequence:

  1. (10, 10, 58, 31, 63, 40, 76)
  2. (10, 58, 10, 31, 63, 40, 76)
  3. (10, 58, 10, 31, 63, 76, 40)
  4. (10, 58, 10, 31, 76, 63, 40)
  5. (10, 58, 31, 10, 76, 63, 40)
  6. (10, 58, 31, 76, 10, 63, 40)
  7. (10, 58, 31, 76, 63, 10, 40)
  8. (10, 58, 76, 31, 63, 10, 40)
  9. (10, 76, 58, 31, 63, 10, 40)
  10. (76, 10, 58, 31, 63, 10, 40)
  11. (76, 10, 58, 31, 63, 40, 10)
from collections import Counter
import string
import math
import sys
# import random
# sys.setrecursionlimit(10**6) 
from fractions import Fraction
from itertools import product
def array_int():
    return [int(i) for i in sys.stdin.readline().split()]
def vary(arrber_of_variables):
    if arrber_of_variables==1:
        return int(sys.stdin.readline())
    if arrber_of_variables>=2:
        return map(int,sys.stdin.readline().split()) 
def makedict(var):
    return dict(Counter(var))
# i am noob wanted to be better and trying hard for that
def printDivisors(n): 
    divisors=[]  
    # Note that this loop runs till square root 
    i = 1
    while i <= math.sqrt(n): 
          
        if (n % i == 0) : 
              
            # If divisors are equal, print only one 
            if (n//i == i) : 
                divisors.append(i) 
            else : 
                # Otherwise print both 
                divisors.extend((i,n//i)) 
        i = i + 1
    return divisors
def countTotalBits(num):
     binary = bin(num)[2:]
     return(len(binary))
def isPrime(n):
    # Corner cases 
    if (n <= 1) : 
        return False
    if (n <= 3) : 
        return True
  
    # This is checked so that we can skip  
    # middle five numbers in below loop 
    if (n % 2 == 0 or n % 3 == 0) : 
        return False
  
    i = 5
    while(i * i <= n) : 
        if (n % i == 0 or n % (i + 2) == 0) : 
            return False
        i = i + 6
  
    return True
mod=10**9+7
# def ncr(n,r):
#     if n<r:
#         return 0
#     if n==r:
#         return 1
#     numer=fact[n]
#     # print(numer)
#     denm=(fact[n-r]*fact[r])
#     # print(denm)
#     return numer*pow(denm,mod-2,mod)
# def dfs(node):
#     global graph,m,cats,count,visited,val
#     # print(val)
#     visited[node]=1
#     if cats[node]==1:
#         val+=1
    
    
#     # print(val)
#     for i in graph[node]:
#         if visited[i]==0:
#             z=dfs(i)
#             # print(z,i)
#             count+=z
#         val-=1
#         return 0
#     else:
#         return 1
    
    
# fact=[1]*(1001)
# c=1
# mod=10**9+7
# for i in range(1,1001):
# print(fact)
def comp(x):
#     fact[i]=(fact[i-1]*i)%mod
    return x[1]
def SieveOfEratosthenes(n): 
    # Create a boolean array "prime[0..n]" and initialize 
    #  all entries it as true. A value in prime[i] will 
    # finally be false if i is Not a prime, else true. 
    prime = [True for i in range(n+1)] 
    p = 2
    while (p * p <= n): 
          
        # If prime[p] is not changed, then it is a prime 
        if (prime[p] == True): 
              
            # Update all multiples of p 
            for i in range(p * p, n+1, p): 
                prime[i] = False
        p += 1
    primes=[]
    # Print all prime numbers 
    for p in range(2, n+1): 
        if prime[p]: 
            primes.append(p*p)
# primes=[]
# SieveOfEratosthenes(2*(10**6))
def lcm(a,b):
    return (a*b)//math.gcd(a,b)
def primeFactors(n): 
    factors=[]
    # Print the number of two's that divide n 
    while n % 2 == 0: 
        factors.append(2) 
        n = n // 2
    # n must be odd at this point 
    # so a skip of 2 ( i = i + 2) can be used 
    for i in range(3,int(math.sqrt(n))+1,2):   
        # while i divides n , print i ad divide n 
        while n % i== 0: 
            factors.append(i)
            n = n // i
    # Condition if n is a prime 
    # number greater than 2 
    if n > 2: 
        factors.append(n)
    return factors
mod=10**9+7
testCases=1
# testCases=vary(1)
for _ in range(testCases):
    n=vary(1)
    num=array_int()
    maxi=num.index(max(num))
    for i in range(maxi,0,-1):
        num[i],num[i-1]=num[i-1],num[i]
    print(maxi+num[::-1].index(min(num)))
    