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.InputStream;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Little_Pony_and_Sort_by_Shift_454 {

    public static void main(String[] args) throws IOException {
        input();
        solve();

    }

    static void solve() {
        int res = 0;
        int count = 0;
        int firstEle = a[0];
        int beforeEle = firstEle;
        boolean check = false;
        for (int i = 1; i < n; i++) {
            if (!check) {
                if (a[i] >= beforeEle) {
                    beforeEle = a[i];
                } else {
                    if (a[i] > firstEle) {
                        count = -1;
                        break;
                    }
                    check = true;
                    beforeEle = a[i];
                    count++;
                }
            } else {

                if (a[i] > firstEle) {
                    count = -1;
                    break;
                }
                if (a[i] >= beforeEle) {
                    count++;
                    beforeEle = a[i];
                } else {
                    count = -1;
                    break;
                }
            }
        }
        res = count;
        System.out.println(res);
    }

    /******************************************************************
     ****************************** INPUT******************************
     ******************************************************************/

    static int[] a;
    static int n;

    static void input() throws IOException {
        Init(System.in);
        n = NextInt();
        a = new int[n];
        for (int i = 0; i < n; i++) {
            a[i] = NextInt();
        }
    }

    /******************************************************************
     ****************************** READER*****************************
     ******************************************************************/
    static BufferedReader reader;
    static StringTokenizer tokenizer;

    static void Init(InputStream input) {
        reader = new BufferedReader(new InputStreamReader(input));
        tokenizer = new StringTokenizer("");
    }

    static String Next() throws IOException {

        while (!tokenizer.hasMoreTokens()) {
            tokenizer = new StringTokenizer(reader.readLine());
        }
        return tokenizer.nextToken();
    }

    static int NextInt() throws IOException {

        return Integer.parseInt(Next());
    }

    static long NextLong() throws IOException {

        return Long.parseLong(Next());
    }

    static Double NextDouble() throws IOException {

        return Double.parseDouble(Next());
    }
}
