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.
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000005;
int n, p[MAXN];
long long sum1_pos = 0, sum1_neg = 0, sum2_pos = 0, sum2_neg = 0;
int cnt1_pos = 0, cnt1_neg = 0, cnt2_pos = 0, cnt2_neg = 0;
vector<int> G[MAXN];
long long cal(int k) {
  long long ret = 0;
  ret += sum1_pos - (long long)k * cnt1_pos;
  ret += (long long)k * cnt1_neg + sum1_neg;
  ret += sum2_pos - (long long)(k - n) * cnt2_pos;
  ret += (long long)(k - n) * cnt2_neg + sum2_neg;
  return ret;
}
void del(int v, int d) {
  if (v + d < n) {
    if (p[v] > v + d) {
      sum1_pos -= p[v] - v;
      cnt1_pos--;
    } else {
      sum1_neg -= v - p[v];
      cnt1_neg--;
    }
  } else {
    int x = (v + d) % n;
    if (p[v] > x) {
      sum2_pos -= p[v] - v;
      cnt2_pos--;
    } else {
      sum2_neg -= v - p[v];
      cnt2_neg--;
    }
  }
}
void add(int v, int d) {
  if (v + d < n) {
    if (p[v] > v + d) {
      sum1_pos += p[v] - v;
      cnt1_pos++;
      G[p[v] - v].push_back(v);
    } else {
      sum1_neg += v - p[v];
      cnt1_neg++;
      G[n - v].push_back(v);
    }
  } else {
    int x = (v + d) % n;
    if (p[v] > x) {
      sum2_pos += p[v] - v;
      cnt2_pos++;
      if (d + p[v] - x < n) G[d + p[v] - x].push_back(v);
    } else {
      sum2_neg += v - p[v];
      cnt2_neg++;
      if (d + n - x < n) G[d + n - x].push_back(v);
    }
  }
}
void update(int v, int k) {
  del(v, k - 1);
  add(v, k);
}
int main() {
  scanf("%d", &n);
  for (int i = 0; i < n; i++) {
    scanf("%d", &p[i]);
    p[i]--;
    if (p[i] > i) {
      sum1_pos += p[i] - i;
      cnt1_pos++;
      G[p[i] - i].push_back(i);
    } else {
      sum1_neg += i - p[i];
      cnt1_neg++;
      G[n - i].push_back(i);
    }
  }
  long long ans = LLONG_MAX;
  int ansid = 0;
  for (int k = 0; k < n; k++) {
    for (int i = 0; i < G[k].size(); i++) {
      int v = G[k][i];
      update(v, k);
    }
    long long t = cal(k);
    if (t < ans) {
      ans = t;
      ansid = k;
    }
  }
  printf("%lld %d", ans, ansid);
  return 0;
}
