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. 
#!/usr/bin/env python3

def solve():
    n = get(int)
    ar = get([int])

    counts = defaultdict(int)
    runsum = 0
    ans = 0
    for i, v in enumerate(ar):
        c = counts[v] + counts[v-1] + counts[v+1]
        ans += v * (i-c) - runsum + counts[v]*v + counts[v-1]*(v-1) + counts[v+1]*(v+1)
        runsum += v
        counts[v] += 1
    return ans










_testcases = """
5
1 2 3 1 3

4



4
6 6 5 5

0




4
6 6 4 4

-8
""".strip()

# ======================= B O I L E R P L A T E ======================= #
# Practicality beats purity

from bisect import bisect_left, bisect_right
from functools import lru_cache
from heapq import heapify, heappop, heappush
from operator import itemgetter, attrgetter
from collections import defaultdict
import bisect
import collections
import functools
import heapq
import itertools
import math
import operator
import re
import string
import sys

inf = float('inf')
cache = lru_cache(None)
sys.setrecursionlimit(10000)

def tree():
    return collections.defaultdict(tree)

def equal(x, y, epsilon=1e-6):
    # https://code.google.com/codejam/kickstart/resources/faq#real-number-behavior
    if -epsilon <= x - y <= epsilon:
        return True
    if -epsilon <= x <= epsilon or -epsilon <= y <= epsilon:
        return False
    return (-epsilon <= (x - y) / x <= epsilon or -epsilon <= (x - y) / y <= epsilon)


def get(_type):  # For easy input
    if type(_type) == list:
        if len(_type) == 1:
            _type = _type[0]
            return list(map(_type, input().strip().split()))
        else:
            return [_type[i](inp) for i, inp in enumerate(input().strip().split())]
    else:
        return _type(input().strip())

if __name__ == '__main__':
    printRecursionTree = timeit = lambda x: x
    _p, print = print, lambda *a, **b: None
    _p(solve())
