One day, Twilight Sparkle is interested in how to sort a sequence of integers a1, a2, ..., an in non-decreasing order. Being a young unicorn, the only operation she can perform is a unit shift. That is, she can move the last element of the sequence to its beginning:

a1, a2, ..., an → an, a1, a2, ..., an - 1.

Help Twilight Sparkle to calculate: what is the minimum number of operations that she needs to sort the sequence?

Input

The first line contains an integer n (2 ≤ n ≤ 105). The second line contains n integer numbers a1, a2, ..., an (1 ≤ ai ≤ 105).

Output

If it's impossible to sort the sequence output -1. Otherwise output the minimum number of operations Twilight Sparkle needs to sort it.

Examples

Input

2
2 1


Output

1


Input

3
1 3 2


Output

-1


Input

2
1 2


Output

0
import java.util.* ;
import java.io.*;



public class main {
static boolean sol(int ar[] ,int in)
{

for(int i = in + 1 ; i < ar.length - 1 ; i++)
    if( !(ar[i] <= ar[i+1]) )
        return false;
       
 
    return true ;
}

    public static void main(String[] args) throws Exception{
      BufferedReader bf = new BufferedReader(new InputStreamReader(System.in)) ;
      StringTokenizer str =  new StringTokenizer (bf.readLine()) ;
      int size = Integer.parseInt(str.nextToken()) ;
      str =  new StringTokenizer (bf.readLine()) ;
      int ar [] = new int [size] ;
      for(int i = 0 ; i < size ; i++)
        ar[i] = Integer.parseInt(str.nextToken()) ; int ind = 0 ;
      for(int i = 0 ; i < size - 1 ; i++)
          if(ar[i] <= ar[i+1])
              ind++ ;
          else 
              break;
      if(sol(ar, ind) && ar[0] >= ar[size - 1] || ind == size - 1)
            System.out.println(size - (ind + 1 ));
      else 
            System.out.println(-1);
      
          }}
    
