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.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class RotatedSortedArray {

    /**
     * @param args
     * @throws IOException
     * @throws NumberFormatException
     */
    public static void main(String[] args) throws NumberFormatException,
            IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int N = Integer.parseInt(br.readLine());
        String[] input = br.readLine().split(" ");
        int[] ar = new int[input.length];
        for (int i = 0; i < N; i++) {
            ar[i] = Integer.parseInt(input[i]);
        }
        int i = findoutlierpoint(ar, 0, ar.length - 1);
        //System.out.println(i);
        if (i == -1) {
            System.out.println(0);
        } else {
            //System.out.println(issorted(ar, 0, i-1));
            //System.out.println(issorted(ar, i + 1, ar.length - 1));
            //System.out.println(ar[0] >= ar[ar.length - 1]);
            if (issorted(ar, 0, i-1) && issorted(ar, i, ar.length - 1)
                    && ar[0] >= ar[ar.length - 1]) {
                System.out.println((ar.length-i));
            }else{
                System.out.println(-1);
            }
        }

    }

    private static boolean issorted(int[] ar, int i, int j) {
        if(i>=j){
            return true;
        }
        for (int f = i; f < j; f++) {
            if (ar[f + 1] < ar[f]) {
                return false;
            }
        }
        return true;
    }

    private static int findoutlierpoint(int[] ar, int lo, int hi) {
        int outlier = -1;
        for (int i = lo + 1; i <= hi; i++) {
            if (ar[i] < ar[i - 1]) {
                outlier = i;
                break;
            }
        }
        return outlier;
    }

}
