There are N towns on a line running east-west.
The towns are numbered 1 through N, in order from west to east.
Each point on the line has a one-dimensional coordinate, and a point that is farther east has a greater coordinate value.
The coordinate of town i is X_i.
You are now at town 1, and you want to visit all the other towns.
You have two ways to travel:
 - Walk on the line.
Your fatigue level increases by A each time you travel a distance of 1, regardless of direction.
 - Teleport to any location of your choice.
Your fatigue level increases by B, regardless of the distance covered.
Find the minimum possible total increase of your fatigue level when you visit all the towns in these two ways.

-----Constraints-----
 - All input values are integers.
 - 2≤N≤10^5
 - 1≤X_i≤10^9
 - For all i(1≤i≤N-1), X_i<X_{i+1}.
 - 1≤A≤10^9
 - 1≤B≤10^9

-----Input-----
The input is given from Standard Input in the following format:
N A B
X_1 X_2 ... X_N

-----Output-----
Print the minimum possible total increase of your fatigue level when you visit all the towns.

-----Sample Input-----
4 2 5
1 2 5 7

-----Sample Output-----
11

From town 1, walk a distance of 1 to town 2, then teleport to town 3, then walk a distance of 2 to town 4.
The total increase of your fatigue level in this case is 2×1+5+2×2=11, which is the minimum possible value.

```python

USER_FILENAME = "<user_code>"
import sys, json, builtins
import math, heapq, bisect, itertools, functools, collections, statistics, fractions, decimal, operator, array, random, re, string, os, pathlib
try:
    import resource as _res
except Exception:
    _res = None
from collections import Counter, defaultdict, deque, OrderedDict
from functools import lru_cache, reduce
from itertools import accumulate, permutations, combinations, product
from math import gcd, ceil, floor, sqrt
from decimal import Decimal
try:
    from typing import *
except Exception:
    pass
try:
    sys.setrecursionlimit(1_000_000)
except Exception:
    pass
try:
    import site as _site
    try:
        _sys_sites = _site.getsitepackages() if hasattr(_site, "getsitepackages") else []
        for _p in _sys_sites:
            if _p and _p not in sys.path:
                sys.path.append(_p)
    except Exception:
        pass
    try:
        _usp = _site.getusersitepackages()
        if isinstance(_usp, str):
            _usp = [_usp]
        for _p in _usp:
            if _p and _p not in sys.path:
                sys.path.append(_p)
    except Exception:
        pass
except Exception:
    pass

ns = {"__name__": "__main__"}
for _k, _v in list(globals().items()):
    if not _k.startswith("_"):
        ns[_k] = _v
_CODE = 'import sys\nimport os\nfrom copy import copy\nimport operator\nimport time\nimport datetime\nimport math\nfrom math import floor, ceil, sqrt, log\nimport statistics\nfrom statistics import mean, median\nfrom decimal import Decimal as D\nfrom fractions import Fraction as F\nimport functools\nimport random\nfrom random import randint, shuffle\nimport bisect\nimport string\nfrom collections import deque\nimport collections\nimport itertools\nimport heapq\n\nsys.setrecursionlimit(4100000)\nproduct = functools.partial(functools.reduce, operator.mul)\nINF = float("inf")\n\n\nclass UnionFind:\n    def __init__(self, n):\n        self.parents = [-1] * n\n\n    def union(self, x, y):\n        x, y = self.find(x), self.find(y)\n        if x != y:\n            if self.parents[x] > self.parents[y]:\n                x, y = y, x\n            self.parents[x] += self.parents[y]\n            self.parents[y] = x\n\n    def find(self, x):\n        if self.parents[x] < 0:\n            return x\n        self.parents[x] = self.find(self.parents[x])\n        return self.parents[x]\n\n    def size(self, x):\n        return -self.parents[self.find(x)]\n\n    def same(self, x, y):\n        return self.find(x) == self.find(y)\n\n    def members(self, x):\n        root = self.find(x)\n        return [i for i in range(self.n) if self.find(i) == root]\n\n    def roots(self):\n        return list(filter(lambda x: x < 0, self.parents))\n\n    def group_count(self):\n        return len(self.roots())\n\n    def max_size(self):\n        return -min(self.parents)\n\n    def min_size(self):\n        return -max(self.roots())\n\n    def append(self, n):\n        self.parents += [-1] * n\n\n\nclass Imos:\n    def __init__(self, n):\n        self.val = [0] * n\n\n    def add(self, x, y, n=None):\n        if n is None:\n            n = 1\n        self.val[x] += n\n        if len(self.val) > y + 1:\n            self.val[y + 1] -= n\n\n    def imos(self):\n        for i in range(1, len(self.val)):\n            self.val[i] += self.val[i - 1]\n\n    def max(self):\n        return max(self.val)\n\n    def min(self):\n        return min(self.val)\n\n\nclass CS:\n    def __init__(self, grid):\n        self.cs = grid\n        for i0 in range(len(grid)):\n            for i1 in range(len(grid[0])):\n                if i0 == 0:\n                    if i1 == 0:\n                        continue\n                    self.cs[i0][i1] += self.cs[i0][i1 - 1]\n                else:\n                    if i1 == 0:\n                        self.cs[i0][i1] += self.cs[i0 - 1][i1]\n                    else:\n                        self.cs[i0][i1] += self.cs[i0 - 1][i1] + self.cs[i0][i1 - 1] - \\\n                                           self.cs[i0 - 1][i1 - 1]\n\n    def sum(self, start_0, start_1, end_0, end_1):\n        if start_0 == 0:\n            if start_1 == 0:\n                return self.cs[end_0][end_1]\n            return self.cs[end_0][end_1] - self.cs[end_0][start_1 - 1]\n        if start_1 == 0:\n            return self.cs[end_0][end_1] - self.cs[start_0 - 1][end_1]\n        start_0 -= 1\n        start_1 -= 1\n        return self.cs[end_0][end_1] - self.cs[start_0][end_1] - self.cs[end_0][\n            start_1] + self.cs[start_0][start_1]\n\n\ndef mod(n):\n    return n % (10 ** 9 + 7)\n\n\ndef sinput():\n    return sys.stdin.readline()[:-1]\n\n\ndef input():\n    inputs = list(map(int, sys.stdin.readline().split()))\n    if len(inputs) == 1:\n        return inputs[0]\n    return inputs\n\n\ndef listban(l):\n    return list(map(list, set(map(tuple, l))))\n\n\ndef div(n):\n    lower_divisors, upper_divisors = [], []\n    i = 1\n    while i * i <= n:\n        if n % i == 0:\n            lower_divisors.append(i)\n            if i != n // i:\n                upper_divisors.append(n // i)\n        i += 1\n    return lower_divisors + upper_divisors[::-1]\n\n\ndef prime(n):\n    a = []\n    while n % 2 == 0:\n        a.append(2)\n        n //= 2\n    f = 3\n    while f * f <= n:\n        if n % f == 0:\n            a.append(f)\n            n //= f\n        else:\n            f += 2\n    if n != 1:\n        a.append(n)\n    return a\n\n\ndef div_counter(l, n):\n    return prime(l).count(n)\n\n\ndef lcm(x, y):\n    return (x * y) // math.gcd(x, y)\n\n\ndef C(n, r):\n    if n < r:\n        return 0\n    return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))\n\n\ndef P(n, r):\n    if n < r:\n        return 0\n    return math.factorial(n) // math.factorial(n - r)\n\n\ndef H(n, r):\n    return C(n + r - 1, r)\n\n\ndef cos(x, y, a):\n    return (x ** 2 + y ** 2 - 2 * x * y * math.cos(math.radians(a))) ** 0.5\n\n\ndef DFS(g, s, pos=None):\n    if pos is None:\n        pos = set()\n    pos.add(s)\n    for i in g[s]:\n        if not (i in pos):\n            DFS(g, i, pos)\n    return pos\n\n\ndef DFS_one(g, s, pos=None):\n    if pos is None:\n        pos = set()\n    pos = copy(pos)\n    pos.add(s)\n    b = copy(pos)\n    m = copy(pos)\n    for i in g[s]:\n        if not (i in pos):\n            b = DFS(g, i, pos)\n            if len(m) < len(b):\n                m = b\n    return m\n\n\ndef BFS(g, q, pos=None):\n    if pos is None:\n        pos = set()\n    if type(q) == deque:\n        pos.add(q)\n        q = deque([q])\n    pos.add(q[-1])\n    for i in g[q.pop()]:\n        if not i in pos:\n            q.append(i)\n    while q != deque():\n        pos, q = BFS(g, q, pos)\n    return pos, q\n\n\ndef SSP(a, li=None):\n    if li is None:\n        li = []\n    if len(a) == 1:\n        return [a[0]]\n    return list(set(\n        li + SSP(a[1:], li) + list(map(lambda x: x + a[0], SSP(a[1:], li))) + [a[0]]))\n\n\ndef dijkstra(g, s):\n    n = len(g)\n    dist = [10 ** 100] * n\n    hq = [(0, s)]\n    dist[s] = 0\n    seen = [False] * n\n    while hq:\n        v = heapq.heappop(hq)[1]\n        seen[v] = True\n        for to, cost in g[v]:\n            if seen[to] == False and dist[v] + cost < dist[to]:\n                dist[to] = dist[v] + cost\n                heapq.heappush(hq, (dist[to], to))\n    return dist\n\n\ndef LIS(b):\n    l = [b[0]]\n    for i in b:\n        if i > l[-1]:\n            l += [i]\n        else:\n            l[bisect.bisect_left(l, i)] = i\n    return len(l)\n\n\ndef two(n):\n    return len(str(bin(n))) - str(bin(n)).rfind("1") - 1\n\n\ndef yn(b):\n    if b:\n        print("Yes")\n    else:\n        print("No")\n\n\ndef op(s):\n    print(s)\n    return()\n\n\nn, a, b = input()\nx = input()\nans = 0\nfor i in range(1, n):\n    ans += min((x[i] - x[i-1])*a, b)\nprint(ans)'
_co = compile(_CODE, USER_FILENAME, "exec")
exec(_co, ns, ns)

```

Measured memory_bytes: 511163