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
		/*input

		*/
		import java.io.ByteArrayInputStream;
		import java.io.IOException;
		import java.io.InputStream;
		import java.io.PrintWriter;
		import java.util.*;
		import java.io.*;
		public class Main {
		InputStream is;
			PrintWriter out;
			String INPUT = ""; 
		//class Declaration
		static class pair implements Comparable<pair>{
			int x,y;
			
			pair (int i,int j)
			{ x=i; y=j;
				
			}
			public int compareTo(pair p){
				if(this.x!=p.x) { return this.x-p.x;}
				else { return this.y-p.y;}
			}
			public int hashCode() { return (x+" "+y).hashCode();}
			public String toString(){ return x+" "+y;} 
			public boolean equals(Object o){ 
				pair x = (pair) o ;
				return (x.x==this.x&&x.y==this.y);}
		}

	void solve() {
		int n=ni();
		int[] arr = na(n);

		int mini=-1;
		int min =Integer.MAX_VALUE;
		for(int i=0;i<n;++i){
			if(min>=arr[i]){
				min =arr[i];
				mini =i;
			}
		
		}
		while(mini-1>=0 && arr[mini]==arr[mini-1]) mini--;
		
		boolean f= true;
		for(int j=0;j<n-1;++j){
			if(arr[(mini+j)%n]<=arr[(mini+j+1)%n]){
				continue;
			}
			else{
				f=false;
			}
		} 
		if(!f)  pn(-1);
		else{
			pn((n-mini)%n);
		}

	}

	int gcd(int a, int b) 
	{ 
	if (b == 0) 
		return a; 
	return gcd(b, a % b);  
	} 


		void run() throws Exception
		{
				is = INPUT.isEmpty() ? System.in : new ByteArrayInputStream(INPUT.getBytes());
				out = new PrintWriter(System.out);
				
				long s = System.currentTimeMillis();
				solve();
				out.flush();
				if(!INPUT.isEmpty())tr(System.currentTimeMillis()-s+"ms");
		}
			
			
			public static void main(String[] args) throws Exception { new Main().run(); }
			
		//output methods
		private void pn(Object o)
		{
			out.println(o);
		}
		private void p(Object o)
		{
			out.print(o);
		}



		//input methods
				private byte[] inbuf = new byte[1024];
			public int lenbuf = 0, ptrbuf = 0;
			

			private int readByte()
			{
				if(lenbuf == -1)throw new InputMismatchException();
				if(ptrbuf >= lenbuf){
					ptrbuf = 0;
					try { lenbuf = is.read(inbuf); } catch (IOException e) { throw new InputMismatchException(); }
					if(lenbuf <= 0)return -1;
				}
				return inbuf[ptrbuf++];
			}
			
			private boolean isSpaceChar(int c) { return !(c >= 33 && c <= 126); }
			private int skip() { int b; while((b = readByte()) != -1 && isSpaceChar(b)); return b; }
			
			private double nd() { return Double.parseDouble(ns()); }
			private char nc() { return (char)skip(); }
			
			private String ns()
			{
				int b = skip();
				StringBuilder sb = new StringBuilder();
				while(!(isSpaceChar(b))){ // when nextLine, (isSpaceChar(b) && b != ' ')
					sb.appendCodePoint(b);
					b = readByte();
				}
				return sb.toString();
			}
			
			private char[] ns(int n)
			{
				char[] buf = new char[n];
				int b = skip(), p = 0;
				while(p < n && !(isSpaceChar(b))){
					buf[p++] = (char)b;
					b = readByte();
				}
				return n == p ? buf : Arrays.copyOf(buf, p);
			}
				
			private char[][] nm(int n, int m)
			{
				char[][] map = new char[n][];
				for(int i = 0;i < n;i++)map[i] = ns(m);
				return map;
			}
			
			private int[] na(int n)
			{
				int[] a = new int[n];
				for(int i = 0;i < n;i++)a[i] = ni();
				return a;
			}
			
			private int ni()
			{
				int num = 0, b;
				boolean minus = false;
				while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
				if(b == '-'){
					minus = true;
					b = readByte();
				}
				
				while(true){
					if(b >= '0' && b <= '9'){
						num = num * 10 + (b - '0');
					}else{
						return minus ? -num : num;
					}
					b = readByte();
				}
			}
			
			private long nl()
			{
				long num = 0;
				int b;
				boolean minus = false;
				while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
				if(b == '-'){
					minus = true;
					b = readByte();
				}
				
				while(true){
					if(b >= '0' && b <= '9'){
						num = num * 10 + (b - '0');
					}else{
						return minus ? -num : num;
					}
					b = readByte();
				}
			}
			
			private void tr(Object... o) { if(INPUT.length() > 0)System.out.println(Arrays.deepToString(o)); }
		}

