Let's denote a function 

<image>

You are given an array a consisting of n integers. You have to calculate the sum of d(ai, aj) over all pairs (i, j) such that 1 ≤ i ≤ j ≤ n.

Input

The first line contains one integer n (1 ≤ n ≤ 200000) — the number of elements in a.

The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 109) — elements of the array. 

Output

Print one integer — the sum of d(ai, aj) over all pairs (i, j) such that 1 ≤ i ≤ j ≤ n.

Examples

Input

5
1 2 3 1 3


Output

4


Input

4
6 6 5 5


Output

0


Input

4
6 6 4 4


Output

-8

Note

In the first example:

  1. d(a1, a2) = 0; 
  2. d(a1, a3) = 2; 
  3. d(a1, a4) = 0; 
  4. d(a1, a5) = 2; 
  5. d(a2, a3) = 0; 
  6. d(a2, a4) = 0; 
  7. d(a2, a5) = 0; 
  8. d(a3, a4) = - 2; 
  9. d(a3, a5) = 0; 
  10. d(a4, a5) = 2. 
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Scanner;
import java.util.HashMap;
import java.math.BigInteger;
import java.util.TreeSet;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author Aeroui
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        Scanner in = new Scanner(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskD solver = new TaskD();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskD {
        private int MAXN = (int) 2e5 + 5;
        int n = 0;
        int N = 1;
        int[] a = new int[MAXN];
        long[] B = new long[MAXN];
        long[] C = new long[MAXN];
        BigInteger ans = BigInteger.ZERO;
        TreeSet<Integer> S = new TreeSet<>();
        HashMap<Integer, Integer> M = new HashMap<>();
        HashMap<Integer, Integer> MR = new HashMap<>();

        void update(int i, int val) {
            while (i <= N) {
                B[i] += val;
                ++C[i];
                i += (i & -i);
            }
        }

        Long getV(int i) {
            long sum = 0;
            while (i > 0) {
                sum += B[i];
                i -= (i & -i);
            }
            return sum;
        }

        long getV(int i, int j) {
            if (i > j) return 0;
            j = Math.min(N, j);
            if (i == 0) return getV(j);
            return getV(j) - getV(i - 1);
        }

        long getC(int i) {
            long sum = 0;
            while (i > 0) {
                sum += C[i];
                i -= (i & -i);
            }
            return sum;
        }

        long getC(int i, int j) {
            if (i > j) return 0l;
            j = Math.min(N, j);
            if (i == 0) return getC(j);
            return getC(j) - getC(i - 1);
        }

        public void solve(int testNumber, Scanner in, PrintWriter out) {
            n = in.nextInt();
            for (int i = 1; i <= n; ++i) {
                a[i] = in.nextInt();
                S.add(a[i]);
            }


            for (Integer x : S)
                if (M.getOrDefault(x, 0) == 0) {
                    M.put(x, N);
                    MR.put(N, x);
                    ++N;
                }
            M.put(0, N);
            MR.put(N, 0);

            for (int i = 1; i <= n; ++i) {
                int x = a[i];
                int xi = M.getOrDefault(x, 0);
                int nxti = Math.min(N, xi + 2);
                int prvi = Math.max(0, xi - 2);

                if (xi - 1 > 0 && Math.abs(MR.getOrDefault(xi - 1, 0) - x) > 1)
                    prvi = Math.max(0, xi - 1);
                if (xi + 1 < N && Math.abs(MR.getOrDefault(xi + 1, 0) - x) > 1)
                    nxti = Math.min(N, xi + 1);

                ans = ans.add(new BigInteger("" + (getC(1, prvi) * x - getV(1, prvi))));
                ans = ans.add(new BigInteger("" + (getC(nxti, N - 1) * x - getV(nxti, N - 1))));

                update(xi, x);
            }

            out.println(ans);

        }

    }
}

