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 B {

  static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
  static StringTokenizer st;
  static String rl() throws Exception { return br.readLine(); }
  static void pf(String s, Object...x) { System.out.printf(s, x); }
  static void ln() { System.out.println(); }
  static int pi(String s) { return Integer.parseInt(s); }
  static long pl(String s) { return Long.parseLong(s); }
  static void tok(String s) { st = new StringTokenizer(s); }
  static boolean hmt() { return st.hasMoreTokens(); }
  static String nt() { return st.nextToken(); }

  public static void main(String[] args) throws Exception {
    int n = pi(rl());
    tok(rl());
    int[] x = new int[n];
    for (int i = 0; i < n; i++) {
      x[i] = pi(nt());
    }
    int d = 0;
    for (int i = 0; i < n - 1; i++) {
      if (x[i] > x[i + 1]) {
        d = i + 1;
        break;
      }
    }
    boolean sorted = true;
    for (int i = 0; i < n - 1; i++) {
      if (x[(d + i) % n] > x[(d + i + 1) % n]) {
        sorted = false;
      }
    }
    if (sorted) {
      pf("%d\n", (n - d) % n);
    } else {
      pf("-1\n");
    }
  }
}
