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.HashMap;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.StringTokenizer;
import java.math.BigInteger;
import java.io.BufferedReader;
import java.io.InputStream;

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

    static class AlmostDifference {
        public void solve(int testNumber, InputReader in, PrintWriter out) {
            HashMap<Long, Long> map = new HashMap<>();
            int N = in.nextInt();
            ArrayList<Long> original = new ArrayList<>();
//        N = 200000;
            for (int i = 0; i < N; i++) {
                int a = in.nextInt();
//            int a = 1000000000;
//            if (i >= N/2) {
//                a = 0;
//            }
                original.add((long) (a));
            }
            BigInteger res = BigInteger.ZERO;
            long prefix = 0;
            for (int i = 0; i < N; i++) {
                res = res.add(new BigInteger(Long.toString(((long) (i)) * original.get(i) - prefix)));
                prefix += original.get(i);
                map.putIfAbsent(original.get(i), 0L);
                map.replace(original.get(i), map.get(original.get(i)) + 1);
                res = res.subtract(new BigInteger(Long.toString(map.getOrDefault(original.get(i) - 1, 0L))));
                res = res.add(new BigInteger(Long.toString(map.getOrDefault(original.get(i) + 1, 0L))));
            }
            out.println(res.toString());
        }

    }

    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

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

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

    }
}

