Some time ago Mister B detected a strange signal from the space, which he started to study.

After some transformation the signal turned out to be a permutation p of length n or its cyclic shift. For the further investigation Mister B need some basis, that's why he decided to choose cyclic shift of this permutation which has the minimum possible deviation.

Let's define the deviation of a permutation p as <image>.

Find a cyclic shift of permutation p with minimum possible deviation. If there are multiple solutions, print any of them.

Let's denote id k (0 ≤ k < n) of a cyclic shift of permutation p as the number of right shifts needed to reach this shift, for example:

  * k = 0: shift p1, p2, ... pn, 
  * k = 1: shift pn, p1, ... pn - 1, 
  * ..., 
  * k = n - 1: shift p2, p3, ... pn, p1. 

Input

First line contains single integer n (2 ≤ n ≤ 106) — the length of the permutation.

The second line contains n space-separated integers p1, p2, ..., pn (1 ≤ pi ≤ n) — the elements of the permutation. It is guaranteed that all elements are distinct.

Output

Print two integers: the minimum deviation of cyclic shifts of permutation p and the id of such shift. If there are multiple solutions, print any of them.

Examples

Input

3
1 2 3


Output

0 0


Input

3
2 3 1


Output

0 1


Input

3
3 2 1


Output

2 1

Note

In the first sample test the given permutation p is the identity permutation, that's why its deviation equals to 0, the shift id equals to 0 as well.

In the second sample test the deviation of p equals to 4, the deviation of the 1-st cyclic shift (1, 2, 3) equals to 0, the deviation of the 2-nd cyclic shift (3, 1, 2) equals to 4, the optimal is the 1-st cyclic shift.

In the third sample test the deviation of p equals to 4, the deviation of the 1-st cyclic shift (1, 3, 2) equals to 2, the deviation of the 2-nd cyclic shift (2, 1, 3) also equals to 2, so the optimal are both 1-st and 2-nd cyclic shifts.
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayDeque;
import java.util.PriorityQueue;
import java.util.StringTokenizer;
/*
Alright f*** you java
 */
public class B2 {

	public static void main(String[] args) {
		FS in = new FS();
		PrintWriter out = new PrintWriter(System.out);
		int N = in.nextInt();
		int[] p = new int[N];
		for(int i = 0; i < N; i++) p[i] = in.nextInt() - 1;
		
		
		long curDelta = 0, curVal = 0;
		ArrayDeque<Event> eq[] = new ArrayDeque[N+1];
		for(int i = 0; i <= N; i++) eq[i] = new ArrayDeque<Event>();
		
		for(int i = 0; i < N; i++) {
			curVal += Math.abs(p[i]-i);
			if(p[i] < i) {
				curDelta++;
				eq[N-i].add(new Event(OVERLAP, p[i]));
				eq[(N-i)+p[i]].add(new Event(HITS, p[i]));
//				pq.add(new Event(OVERLAP, N-i, p[i]));
//				pq.add(new Event(HITS, (N-i) + p[i], p[i]));
			}
			else if(p[i] > i) {
				curDelta--;
				eq[N-i].add(new Event(OVERLAP, p[i]));
				eq[p[i] - i].add(new Event(HITS, p[i]));
//				pq.add(new Event(HITS, p[i] - i, p[i]));
//				pq.add(new Event(OVERLAP, N-i, p[i]));
			}
			else {
				curDelta++;
				eq[N-i].add(new Event(OVERLAP, p[i]));
//				pq.add(new Event(OVERLAP, N-i, p[i]));
			}
		}
		
		
		long best = curVal;
		int bestShift = 0;
//		if(eq[0].size() > 0) throw null;
		for(int shift = 1; shift < N; shift++) {
			curVal += curDelta;
			while(eq[shift].size() > 0) {
				Event e = eq[shift].poll();
				if(e.type == HITS) {
					curDelta+=2; // Now increasing answer INSTEAD of decreasing
				}
				else {
					// Overlap
					int oldContribution = N - e.number;
					int newContribution = e.number;
					curVal += (newContribution - oldContribution);
					
					// Answer used to be increasing, but now it's decreasing
					curDelta -= 2;
				}
			}
			if(curVal < best) {
				best = curVal;
				bestShift = shift;
			}
		}
		
		out.println(best+" "+bestShift);
		out.close();
	}

	
	static final int HITS = 1, OVERLAP = 0;
	static class Event {
		int number, type, time;
		public Event(int typee, int numberr) {
			type=typee;
			number=numberr;
		}
	}
	
	static class FS{
		BufferedReader br;
		StringTokenizer st;
		public FS() {
			br = new BufferedReader(new InputStreamReader(System.in));
		}
		String next() {
			while(st == null || !st.hasMoreElements()) {
				try{st = new StringTokenizer(br.readLine());}
				catch(Exception e) {}
			}
			return st.nextToken();
		}
		int nextInt() { return Integer.parseInt(next());}
		long nextLong() { return Long.parseLong(next());}
		double nextDouble() { return Double.parseDouble(next());}
	}
}
