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.InputStreamReader;
import java.io.PrintWriter;
import java.util.*;

public class Main {
    public static void main(String[] args) {
        Deque<Integer> d = new LinkedList<>();
        int n = nextInt();
        for (int i = 0; i < n; i++) {
            d.add(nextInt());
        }

        int minE = Collections.min(d);

        if(new HashSet<Integer>(d).size() == 1 && new HashSet<Integer>(d).contains(minE))
            writer.println(0);
        else {

            int res = 0;
            while (d.getFirst() != minE || d.getLast() == minE) {
                d.addFirst(d.pollLast());
//            System.err.println(d);
                res++;
            }


            int last = -1;
            boolean bad = false;
            for (int i : d) {
                if (i >= last)
                    last = i;
                else bad = true;
            }

            writer.println(bad ? -1 : res);
        }
        writer.close();
    }

    static PrintWriter writer = new PrintWriter(System.out);

    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    static StringTokenizer tokenizer = new StringTokenizer("");

    static String next() {
        while (!tokenizer.hasMoreTokens())
            try {
                tokenizer = new StringTokenizer(br.readLine());
            } catch (Exception e) {
                return null;
            }
        return tokenizer.nextToken();
    }

    static int nextInt() {
        return Integer.parseInt(next());
    }

    static long nextLong() {
        return Long.parseLong(next());
    }

    static double nextDouble() {
        return Double.parseDouble(next());
    }
}