Snuke has an integer sequence A of length N.

He will freely choose an integer b. Here, he will get sad if A_i and b+i are far from each other. More specifically, the sadness of Snuke is calculated as follows:

* abs(A_1 - (b+1)) + abs(A_2 - (b+2)) + ... + abs(A_N - (b+N))



Here, abs(x) is a function that returns the absolute value of x.

Find the minimum possible sadness of Snuke.

Constraints

* 1 \leq N \leq 2 \times 10^5
* 1 \leq A_i \leq 10^9
* All values in input are integers.

Input

Input is given from Standard Input in the following format:


N
A_1 A_2 ... A_N


Output

Print the minimum possible sadness of Snuke.

Examples

Input

5
2 2 3 5 5


Output

2


Input

9
1 2 3 4 5 6 7 8 9


Output

0


Input

6
6 5 4 3 2 1


Output

18


Input

7
1 1 1 1 2 3 4


Output

6

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.StringTokenizer;

public class Main {
    public static void main(final String[] args) {
        final FastScanner scanner = new FastScanner(System.in);
        final int n = scanner.nextInt();
        final long[] arrayForSort = new long[n];
        final long[] nativeArray = new long[n];

        for (int i = 0; i < n; i++) {
            final long tmp = scanner.nextLong();
            arrayForSort[i] = tmp - (i + 1);
            nativeArray[i] = tmp;
        }

        Arrays.sort(arrayForSort);

        if (n % 2 == 0) {
            final long mid1 = arrayForSort[n / 2];
            final long mid2 = arrayForSort[n / 2 - 1];

            long answer1 = 0;
            long answer2 = 0;

            for (int i = 0; i < n; i++) {
                answer1 += Math.abs(nativeArray[i] - (mid1 + i + 1));
                answer2 += Math.abs(nativeArray[i] - (mid2 + i + 1));
            }

            System.out.println(Math.min(answer1,answer2));
        } else {
            final long mid = arrayForSort[(n - 1) / 2];

            long answer = 0;

            for (int i = 0; i < n; i++) {
                answer += Math.abs(nativeArray[i] - (mid + i+1));
            }

            System.out.println(answer);
        }
    }

    static class FastScanner {
        private final BufferedReader reader;
        private StringTokenizer tokenizer;

        FastScanner(final InputStream in) {
            reader = new BufferedReader(new InputStreamReader(in));
            tokenizer = null;
        }

        String next() {
            if (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

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

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