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.

Difficulty: HARD

Solutions:
import sys
stdin = sys.stdin
ip = lambda : int(sp())
fp = lambda : float(sp())
lp = lambda : list(map(int, stdin.readline().split()))
sp = lambda : stdin.readline().rstrip()
yp = lambda : print('Yes')
np = lambda : print('No')
(n, a, b) = lp()
x = lp()
ans = 0
for i in range(n - 1):
	ans += min(b, a * (x[i + 1] - x[i]))
print(ans)


(n, a, b, *X) = map(int, open(0).read().split())
c = 0
for (x0, x1) in zip(X, X[1:]):
	c += min(a * (x1 - x0), b)
print(c)


(N, A, B) = map(int, input().split())
X = list(map(int, input().split()))
ans = 0
for i in range(1, N):
	ans += min(A * (X[i] - X[i - 1]), B)
print(ans)


(n, a, b) = list(map(int, input().split()))
xlist = list(map(int, input().split()))
ans = 0
for i in range(n - 1):
	ans += min((xlist[i + 1] - xlist[i]) * a, b)
print(ans)


import sys
input = sys.stdin.readline
(N, A, B) = map(int, input().split())
X = list(map(int, input().split()))
ans = 0
for i in range(N - 1):
	ans += min((X[i + 1] - X[i]) * A, B)
print(ans)


def main():
	(N, A, B) = map(int, input().split())
	X = list(map(int, input().split()))
	dp = [float('inf')] * (N + 5)
	dp[0] = 0
	for i in range(1, N):
		dp[i] = dp[i - 1] + min((X[i] - X[i - 1]) * A, B)
	print(dp[N - 1])

def __starting_point():
	main()
__starting_point()


(n, a, b) = map(int, input().split())
xx = list(map(int, input().split()))
tired = 0
for i in range(n - 1):
	if (xx[i + 1] - xx[i]) * a < b:
		tired += (xx[i + 1] - xx[i]) * a
	else:
		tired += b
print(tired)


(n, a, b) = map(int, input().split())
x = list(map(int, input().split()))
now = x[0]
fatigue = 0
for v in x:
	if a * (v - now) < b:
		fatigue += a * (v - now)
	else:
		fatigue += b
	now = v
print(fatigue)


import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10 ** 9))
write = lambda x: sys.stdout.write(x + '\n')
(n, a, b) = list(map(int, input().split()))
x = list(map(int, input().split()))
ans = 0
for i in range(n - 1):
	if (x[i + 1] - x[i]) * a > b:
		ans += b
	else:
		ans += (x[i + 1] - x[i]) * a
print(ans)


(n, a, b) = map(int, input().split())
X = list(map(int, input().split()))
dist = []
for i in range(n - 1):
	dist.append(X[i + 1] - X[i])
ans = 0
for d in dist:
	if d * a > b:
		ans += b
	else:
		ans += d * a
print(ans)


ii = lambda : int(input())
mi = lambda : map(int, input().split())
li = lambda : list(map(int, input().split()))
(N, A, B) = mi()
X = li()
ans = 0
now = X[0]
for x in X[1:]:
	if (x - now) * A > B:
		ans += B
	else:
		ans += (x - now) * A
	now = x
print(ans)


(N, A, B) = map(int, input().split())
X = list(map(int, input().split()))
dp = 0
for i in range(1, N):
	if A * (X[i] - X[i - 1]) < B:
		dp += A * (X[i] - X[i - 1])
	else:
		dp += B
print(dp)


(n, a, b, *X) = map(int, open(0).read().split())
print(sum((min(a * (X[i + 1] - X[i]), b) for i in range(n - 1))))


(n, a, b) = map(int, input().split())
x = list(map(int, input().split()))
x = [(x[i] - x[i - 1]) * a for i in range(1, n)]
res = 0
for xi in x:
	if xi > b:
		res += b
	else:
		res += xi
print(res)


def main():
	(N, A, B) = list(map(int, input().split()))
	X = list(map(int, input().split()))
	ans = 0
	for i in range(N - 1):
		length = X[i + 1] - X[i]
		ans += min(length * A, B)
	print(ans)

def __starting_point():
	main()
__starting_point()


(n, a, b) = map(int, input().split())
x = list(map(int, input().split()))
dp = [float('inf')] * n
dp[0] = 0
for i in range(n - 1):
	dp[i + 1] = dp[i] + min((x[i + 1] - x[i]) * a, b)
print(dp[-1])


(n, a, b) = map(int, input().split())
x = list(map(int, input().split()))
kirikawari = int(b // a)
ans = 0
for i in range(n - 1):
	sa = x[i + 1] - x[i]
	if sa <= kirikawari:
		ans += sa * a
	else:
		ans += b
print(ans)


def main():
	(N, A, B) = map(int, input().split())
	X = list(map(int, input().split()))
	cost = 0
	for i in range(N - 1):
		distance = abs(X[i] - X[i + 1])
		if distance * A < B:
			cost += distance * A
		else:
			cost += B
	print(cost)

def __starting_point():
	main()
__starting_point()


(N, A, B) = list(map(int, input().split()))
X = list(map(int, input().split()))
cost = 0
x_prev = X[0]
for x_next in X[1:]:
	walk_cost = A * (x_next - x_prev)
	tele_cost = B
	cost += min(walk_cost, tele_cost)
	x_prev = x_next
print(cost)


(n, a, b) = [int(i) for i in input().split()]
x = [int(i) for i in input().split()]
ans = 0
tmp = x[0]
for i in x[1:]:
	ans += min((i - tmp) * a, b)
	tmp = i
print(ans)


(n, a, b) = list(map(int, input().split()))
xs = list(map(int, input().split()))
ans = sum([min((xs[i] - xs[i - 1]) * a, b) for i in range(1, n)])
print(ans)


(N, A, B) = map(int, input().split())
X = [int(x) for x in input().split()]
ans = 0
now = X[0]
for i in range(1, N):
	next = X[i]
	walk = (next - now) * A
	ans += min(B, walk)
	now = next
print(ans)


(n, A, B) = map(int, input().split())
x = list(map(int, input().split()))
if A >= B:
	ans = B * (n - 1)
else:
	ans = 0
	for i in range(n - 1):
		a = x[i + 1] - x[i]
		ans += min(a * A, B)
print(ans)


(N, A, B) = map(int, input().split())
X = list(map(int, input().split()))
sx = sorted(X)
ans = 0
for i in range(N - 1):
	d = sx[i + 1] - sx[i]
	if d * A < B:
		ans += d * A
	else:
		ans += B
print(ans)


(N, A, B) = [int(x) for x in input().split()]
X = [int(x) for x in input().split()]
ans = 0
for i in range(N - 1):
	ans += min((X[i + 1] - X[i]) * A, B)
print(ans)


import sys

def IN_I():
	return int(sys.stdin.readline().rstrip())

def IN_LI():
	return list(map(int, sys.stdin.readline().rstrip().split()))

def IN_S():
	return sys.stdin.readline().rstrip()

def IN_LS():
	return list(sys.stdin.readline().rstrip().split())
INF = float('inf')
MOD = 10 ** 9 + 7
(N, A, B) = IN_LI()
X = IN_LI()
ans = 0
for i in range(N - 1):
	d = X[i + 1] - X[i]
	if A * d >= B:
		ans += B
	else:
		ans += A * d
print(ans)


import sys
sys.setrecursionlimit(10 ** 9)

def int1(x):
	return int(x) - 1

def II():
	return int(input())

def MI():
	return list(map(int, input().split()))

def MI1():
	return list(map(int1, input().split()))

def LI():
	return list(map(int, input().split()))

def LI1():
	return list(map(int1, input().split()))

def LLI(rows_number):
	return [LI() for _ in range(rows_number)]

def MS():
	return input().split()

def LS():
	return list(input())

def LLS(rows_number):
	return [LS() for _ in range(rows_number)]

def printlist(lst, k=' '):
	print(k.join(list(map(str, lst))))
INF = float('inf')

def solve():
	(N, A, B) = MI()
	X = LI()
	ans = 0
	for i in range(N - 1):
		ans += min(A * (X[i + 1] - X[i]), B)
	print(ans)

def __starting_point():
	solve()
__starting_point()


def main():
	import sys
	input = lambda : sys.stdin.readline().strip()
	(n, a, b) = map(int, input().split())
	x = list(map(int, input().split()))
	ans = 0
	for i in range(n - 1):
		if (x[i + 1] - x[i]) * a > b:
			ans += b
		else:
			ans += (x[i + 1] - x[i]) * a
	print(ans)

def __starting_point():
	main()
__starting_point()


(N, A, B) = map(int, input().split())
X = list(map(int, input().split()))
print(sum((min((X[i + 1] - X[i]) * A, B) for i in range(N - 1))))


def resolve():
	(N, A, B) = map(int, input().split())
	X = list(map(int, input().split()))
	ans = 0
	for i in range(N - 1):
		res = min((X[i + 1] - X[i]) * A, B)
		ans += res
	print(ans)

def __starting_point():
	resolve()
__starting_point()


(N, A, B) = map(int, input().split())
L = list(map(int, input().split()))
count = 0
for i in range(1, N):
	p = L[i] - L[i - 1]
	if A * p >= B:
		count += B
	else:
		count += A * p
print(count)


import sys
from collections import deque
from copy import deepcopy
from bisect import bisect_left, bisect_right, insort_left, insort_right
from heapq import heapify, heappop, heappush
from itertools import product, permutations, combinations, combinations_with_replacement
from functools import reduce
from math import gcd, sin, cos, tan, asin, acos, atan, degrees, radians
sys.setrecursionlimit(10 ** 6)
INF = 10 ** 20
eps = 1e-20
MOD = 10 ** 9 + 7

def lcm(x, y):
	return x * y // gcd(x, y)

def lgcd(l):
	return reduce(gcd, l)

def llcm(l):
	return reduce(lcm, l)

def powmod(n, i, mod):
	return pow(n, mod - 1 + i, mod) if i < 0 else pow(n, i, mod)

def div2(x):
	return x.bit_length()

def div10(x):
	return len(str(x)) - (x == 0)

def intput():
	return int(input())

def mint():
	return map(int, input().split())

def lint():
	return list(map(int, input().split()))

def ilint():
	return (int(input()), list(map(int, input().split())))

def judge(x, l=['Yes', 'No']):
	print(l[0] if x else l[1])

def lprint(l, sep='\n'):
	for x in l:
		print(x, end=sep)

def ston(c, c0='a'):
	return ord(c) - ord(c0)

def ntos(x, c0='a'):
	return chr(x + ord(c0))

class counter(dict):

	def __init__(self, *args):
		super().__init__(args)

	def add(self, x, d=1):
		self.setdefault(x, 0)
		self[x] += d

	def list(self):
		l = []
		for k in self:
			l.extend([k] * self[k])
		return l

class comb:

	def __init__(self, n, mod=None):
		self.l = [1]
		self.n = n
		self.mod = mod

	def get(self, k):
		(l, n, mod) = (self.l, self.n, self.mod)
		k = n - k if k > n // 2 else k
		while len(l) <= k:
			i = len(l)
			l.append(l[i - 1] * (n + 1 - i) // i if mod == None else l[i - 1] * (n + 1 - i) * powmod(i, -1, mod) % mod)
		return l[k]

def pf(x, mode='counter'):
	C = counter()
	p = 2
	while x > 1:
		k = 0
		while x % p == 0:
			x //= p
			k += 1
		if k > 0:
			C.add(p, k)
		p = p + 2 - (p == 2) if p * p < x else x
	if mode == 'counter':
		return C
	S = set([1])
	for k in C:
		T = deepcopy(S)
		for x in T:
			for i in range(1, C[k] + 1):
				S.add(x * k ** i)
	if mode == 'set':
		return S
	if mode == 'list':
		return sorted(list(S))
(N, A, B) = mint()
X = lint()
dp = [0] * N
for i in range(N - 1):
	dp[i + 1] = dp[i] + min(A * (X[i + 1] - X[i]), B)
print(dp[N - 1])


import math
from math import gcd, pi, sqrt
INF = float('inf')
MOD = 10 ** 9 + 7
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 6)
import itertools
import bisect
import re
from collections import Counter, deque, defaultdict

def iinput():
	return int(input())

def imap():
	return map(int, input().split())

def ilist():
	return list(imap())

def irow(N):
	return [iinput() for i in range(N)]

def sinput():
	return input().rstrip()

def smap():
	return sinput().split()

def slist():
	return list(smap())

def srow(N):
	return [sinput() for i in range(N)]

def main():
	(N, A, B) = imap()
	X = ilist()
	dp = [INF] * N
	dp[0] = 0
	for i in range(N - 1):
		dp[i + 1] = min(dp[i] + (X[i + 1] - X[i]) * A, dp[i] + B)
	print(dp[-1])

def __starting_point():
	main()
__starting_point()


def resolve():
	(N, A, B) = map(int, input().split(' '))
	X = [int(x) for x in input().split(' ')]
	ans = 0
	for i in range(1, N):
		walking_cost = (X[i] - X[i - 1]) * A
		ans += min(walking_cost, B)
	print(ans)
resolve()


(N, A, B) = map(int, input().split())
X = [int(x) for x in input().split()]
score = 0
for i in range(N - 1):
	score += min((X[i + 1] - X[i]) * A, B)
print(score)


(n, a, b) = map(int, input().split())
x = list(map(int, input().split()))
ans = 0
now = x[0]
for xx in x[1:]:
	ans += min((xx - now) * a, b)
	now = xx
print(ans)


import sys
input = sys.stdin.readline

def read():
	(N, A, B) = list(map(int, input().strip().split()))
	X = list(map(int, input().strip().split()))
	return (N, A, B, X)

def solve(N, A, B, X):
	ans = 0
	for i in range(N - 1):
		d = X[i + 1] - X[i]
		ans += min(A * d, B)
	return ans

def __starting_point():
	inputs = read()
	outputs = solve(*inputs)
	if outputs is not None:
		print('%s' % str(outputs))
__starting_point()


(n, a, b) = map(int, input().split())
A = list(map(int, input().split()))
ans = 0
for i in range(n - 1):
	if (A[i + 1] - A[i]) * a < b:
		ans += a * (A[i + 1] - A[i])
	else:
		ans += b
print(ans)


(n, a, b) = list(map(int, input().split()))
x = list(map(int, input().split()))
ans = 0
for i in range(len(x) - 1):
	walk_cost = a * (x[i + 1] - x[i])
	if b < walk_cost:
		ans += b
	else:
		ans += walk_cost
print(ans)


import sys
input_methods = ['clipboard', 'file', 'key']
using_method = 0
input_method = input_methods[using_method]
tin = lambda : map(int, input().split())
lin = lambda : list(tin())
mod = 1000000007

def main():
	(n, a, b) = tin()
	al = lin()
	pos = al[0]
	ret = 0
	for np in al[1:]:
		ret += min(b, (np - pos) * a)
		pos = np
	return ret
isTest = False

def pa(v):
	if isTest:
		print(v)

def input_clipboard():
	import clipboard
	input_text = clipboard.get()
	input_l = input_text.splitlines()
	for l in input_l:
		yield l

def __starting_point():
	if sys.platform == 'ios':
		if input_method == input_methods[0]:
			ic = input_clipboard()
			input = lambda : ic.__next__()
		elif input_method == input_methods[1]:
			sys.stdin = open('inputFile.txt')
		else:
			pass
		isTest = True
	else:
		pass
	ret = main()
	if ret is not None:
		print(ret)
__starting_point()


import sys
(N, A, B) = list(map(int, input().split()))
X = list(map(int, sys.stdin.readline().rsplit()))
res = 0
for i in range(1, N):
	cost = abs(X[i] - X[i - 1]) * A
	if cost < B:
		res += cost
	else:
		res += B
print(res)


(n, a, b) = list(map(int, input().split()))
x = list(map(int, input().split()))
cnt = 0
for i in range(1, n):
	cnt += min(a * (x[i] - x[i - 1]), b)
print(cnt)


(N, A, B) = map(int, input().split())
X = list(map(int, input().split()))
ans = (X[-1] - X[0]) * A
for (x1, x2) in zip(X, X[1:]):
	if (x2 - x1) * A > B:
		ans -= (x2 - x1) * A - B
print(ans)


(n, a, b) = map(int, input().split())
x = list(map(int, input().split()))
current = x[0]
cost = 0
for i in x:
	if (i - current) * a <= b:
		cost += (i - current) * a
		current = i
	else:
		cost += b
		current = i
print(cost)


(n, a, b, *x) = list(map(int, open(0).read().split()))
now = x[0]
ans = 0
for i in range(1, n):
	cost = (x[i] - now) * a
	if cost > b:
		ans += b
	else:
		ans += cost
	now = x[i]
print(ans)


from sys import stdin, setrecursionlimit
import bisect, collections, copy, itertools, math, string
setrecursionlimit(10 ** 9)

def input():
	return stdin.readline().strip()

def main():
	(n, a, b) = list(map(int, input().split()))
	x = list(map(int, input().split()))
	ans = 0
	for i in range(n - 1):
		ans += min((x[i + 1] - x[i]) * a, b)
	print(ans)

def __starting_point():
	main()
__starting_point()


(N, A, B) = map(int, input().split())
X = list(map(int, input().split()))
prev = X[0]
answer = 0
for x in X:
	if A * (x - prev) < B:
		answer += A * (x - prev)
	else:
		answer += B
	prev = x
print(answer)


(n, a, b) = map(int, input().split())
xs = list(map(int, input().split()))
s = xs[0]
rt = 0
for i in xs[1:]:
	rt += min(a * (i - s), b)
	s = i
print(rt)


import sys
input = sys.stdin.readline
mod = 1000000007

def main():
	(n, a, b) = list(map(int, input().split()))
	X = list(map(int, input().split()))
	useb = b // a
	ans = 0
	for i in range(n - 1):
		d = X[i + 1] - X[i]
		if d > useb:
			ans += b
		else:
			ans += d * a
	print(ans)
main()


(n, a, b) = list(map(int, input().split()))
X = list(map(int, input().split()))
p = X[0]
ans = 0
for x in X[1:]:
	d = x - p
	if d * a <= b:
		ans += d * a
	else:
		ans += b
	p = x
print(ans)


(n, a, b) = list(map(int, input().split()))
x = list(map(int, input().split()))
ans = 0
for i in range(1, n):
	toho = a * (x[i] - x[i - 1])
	tele = b
	ans += min(toho, tele)
print(ans)


(n, a, b) = list(map(int, input().split()))
X = list(map(int, input().split()))
Y = [X[i + 1] - X[i] for i in range(n - 1)]
ans = 0
for y in Y:
	if y * a <= b:
		ans += y * a
	else:
		ans += b
print(ans)


(N, A, B) = map(int, input().split())
(*X,) = map(int, input().split())
i = 1
ans = 0
while i < N:
	ans += min(B, A * (X[i] - X[i - 1]))
	i += 1
print(ans)


(n, a, b) = list(map(int, input().split()))
xlist = list(map(int, input().split()))

class UnionFind(list):

	def __init__(self, length):
		super().__init__((-1 for _ in range(length)))

	def root(self, i):
		if self[i] < 0:
			return i
		else:
			self[i] = self.root(self[i])
			return self[i]

	def size(self, i):
		root_i = self.root(i)
		return -1 * self[root_i]

	def same(self, x, y):
		return self.root(x) == self.root(y)

	def unite(self, x, y):
		rx = self.root(x)
		ry = self.root(y)
		if rx == ry:
			return
		if self.size(x) < self.size(y):
			(rx, ry) = (ry, rx)
		self[rx] += self[ry]
		self[ry] = rx
un = UnionFind(n)
for i in range(n - 1):
	if (xlist[i + 1] - xlist[i]) * a <= b:
		un.unite(i, i + 1)
ans = 0
for i in range(n - 1):
	if un.same(i, i + 1):
		ans += (xlist[i + 1] - xlist[i]) * a
	else:
		ans += b
print(ans)


(N, A, B) = list(map(int, input().split()))
X = list(map(int, input().split()))
dp = [float('inf') for _ in range(N)]
dp[0] = 0
for i in range(1, N):
	dp[i] = min(A * (X[i] - X[i - 1]), B, dp[i]) + dp[i - 1]
print(dp[N - 1])


(N, A, B) = list(map(int, input().split()))
X = list(map(int, input().split()))
now = X[0]
ans = 0
for x in X:
	dis = x - now
	tmp = min(A * dis, B)
	ans += tmp
	now = x
print(ans)


import sys

def input():
	return sys.stdin.readline().strip()

def input_int():
	return int(input())

def input_int_list():
	return [int(i) for i in input().split()]

def main():
	(n, a, b) = input_int_list()
	X = input_int_list()
	dp = [0] * n
	for i in range(1, n):
		dp[i] = min(dp[i - 1] + (X[i] - X[i - 1]) * a, dp[i - 1] + b)
	print(dp[n - 1])
	return

def __starting_point():
	main()
__starting_point()


(N, A, B) = list(map(int, input().split()))
L = list(map(int, input().split()))
w = B // A
v = 0
for i in range(N - 1):
	d = L[i + 1] - L[i]
	if d > w:
		v += B
	else:
		v += d * A
print(v)


(n, a, b) = map(int, input().split())
x = list(map(int, input().split()))
l = []
for i in range(n - 1):
	l.append(x[i + 1] - x[i])
ans = 0
for i in l:
	if a * i < b:
		ans += a * i
	else:
		ans += b
print(ans)


(N, A, B, *X) = map(int, open(0).read().split())
print(sum((min(A * (y - x), B) for (x, y) in zip(X, X[1:]))))


3
(N, A, B) = (int(i) for i in input().split())
X = [int(x) for x in input().split()]
ret = 0
for i in range(1, N):
	d = X[i] - X[i - 1]
	if d * A <= B:
		ret += d * A
	else:
		ret += B
print(ret)


(n, a, b) = map(int, input().split())
x = list(map(int, input().split()))
print(sum([min(x[i + 1] * a - x[i] * a, b) for i in range(n - 1)]))


def solve():
	(N, A, B) = map(int, input().split())
	X = list(map(int, input().split()))
	ans = 0
	for i in range(1, N):
		dx = X[i] - X[i - 1]
		if dx * A < B:
			ans += dx * A
		else:
			ans += B
	print(ans)

def __starting_point():
	solve()
__starting_point()


import sys
import os
from copy import copy
import operator
import time
import datetime
import math
from math import floor, ceil, sqrt, log
import statistics
from statistics import mean, median
from decimal import Decimal as D
from fractions import Fraction as F
import functools
import random
from random import randint, shuffle
import bisect
import string
from collections import deque
import collections
import itertools
import heapq
sys.setrecursionlimit(4100000)
product = functools.partial(functools.reduce, operator.mul)
INF = float('inf')

class UnionFind:

	def __init__(self, n):
		self.parents = [-1] * n

	def union(self, x, y):
		(x, y) = (self.find(x), self.find(y))
		if x != y:
			if self.parents[x] > self.parents[y]:
				(x, y) = (y, x)
			self.parents[x] += self.parents[y]
			self.parents[y] = x

	def find(self, x):
		if self.parents[x] < 0:
			return x
		self.parents[x] = self.find(self.parents[x])
		return self.parents[x]

	def size(self, x):
		return -self.parents[self.find(x)]

	def same(self, x, y):
		return self.find(x) == self.find(y)

	def members(self, x):
		root = self.find(x)
		return [i for i in range(self.n) if self.find(i) == root]

	def roots(self):
		return list(filter(lambda x: x < 0, self.parents))

	def group_count(self):
		return len(self.roots())

	def max_size(self):
		return -min(self.parents)

	def min_size(self):
		return -max(self.roots())

	def append(self, n):
		self.parents += [-1] * n

class Imos:

	def __init__(self, n):
		self.val = [0] * n

	def add(self, x, y, n=None):
		if n is None:
			n = 1
		self.val[x] += n
		if len(self.val) > y + 1:
			self.val[y + 1] -= n

	def imos(self):
		for i in range(1, len(self.val)):
			self.val[i] += self.val[i - 1]

	def max(self):
		return max(self.val)

	def min(self):
		return min(self.val)

class CS:

	def __init__(self, grid):
		self.cs = grid
		for i0 in range(len(grid)):
			for i1 in range(len(grid[0])):
				if i0 == 0:
					if i1 == 0:
						continue
					self.cs[i0][i1] += self.cs[i0][i1 - 1]
				elif i1 == 0:
					self.cs[i0][i1] += self.cs[i0 - 1][i1]
				else:
					self.cs[i0][i1] += self.cs[i0 - 1][i1] + self.cs[i0][i1 - 1] - self.cs[i0 - 1][i1 - 1]

	def sum(self, start_0, start_1, end_0, end_1):
		if start_0 == 0:
			if start_1 == 0:
				return self.cs[end_0][end_1]
			return self.cs[end_0][end_1] - self.cs[end_0][start_1 - 1]
		if start_1 == 0:
			return self.cs[end_0][end_1] - self.cs[start_0 - 1][end_1]
		start_0 -= 1
		start_1 -= 1
		return self.cs[end_0][end_1] - self.cs[start_0][end_1] - self.cs[end_0][start_1] + self.cs[start_0][start_1]

def mod(n):
	return n % (10 ** 9 + 7)

def sinput():
	return sys.stdin.readline()[:-1]

def input():
	inputs = list(map(int, sys.stdin.readline().split()))
	if len(inputs) == 1:
		return inputs[0]
	return inputs

def listban(l):
	return list(map(list, set(map(tuple, l))))

def div(n):
	(lower_divisors, upper_divisors) = ([], [])
	i = 1
	while i * i <= n:
		if n % i == 0:
			lower_divisors.append(i)
			if i != n // i:
				upper_divisors.append(n // i)
		i += 1
	return lower_divisors + upper_divisors[::-1]

def prime(n):
	a = []
	while n % 2 == 0:
		a.append(2)
		n //= 2
	f = 3
	while f * f <= n:
		if n % f == 0:
			a.append(f)
			n //= f
		else:
			f += 2
	if n != 1:
		a.append(n)
	return a

def div_counter(l, n):
	return prime(l).count(n)

def lcm(x, y):
	return x * y // math.gcd(x, y)

def C(n, r):
	if n < r:
		return 0
	return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))

def P(n, r):
	if n < r:
		return 0
	return math.factorial(n) // math.factorial(n - r)

def H(n, r):
	return C(n + r - 1, r)

def cos(x, y, a):
	return (x ** 2 + y ** 2 - 2 * x * y * math.cos(math.radians(a))) ** 0.5

def DFS(g, s, pos=None):
	if pos is None:
		pos = set()
	pos.add(s)
	for i in g[s]:
		if not i in pos:
			DFS(g, i, pos)
	return pos

def DFS_one(g, s, pos=None):
	if pos is None:
		pos = set()
	pos = copy(pos)
	pos.add(s)
	b = copy(pos)
	m = copy(pos)
	for i in g[s]:
		if not i in pos:
			b = DFS(g, i, pos)
			if len(m) < len(b):
				m = b
	return m

def BFS(g, q, pos=None):
	if pos is None:
		pos = set()
	if type(q) == deque:
		pos.add(q)
		q = deque([q])
	pos.add(q[-1])
	for i in g[q.pop()]:
		if not i in pos:
			q.append(i)
	while q != deque():
		(pos, q) = BFS(g, q, pos)
	return (pos, q)

def SSP(a, li=None):
	if li is None:
		li = []
	if len(a) == 1:
		return [a[0]]
	return list(set(li + SSP(a[1:], li) + list(map(lambda x: x + a[0], SSP(a[1:], li))) + [a[0]]))

def dijkstra(g, s):
	n = len(g)
	dist = [10 ** 100] * n
	hq = [(0, s)]
	dist[s] = 0
	seen = [False] * n
	while hq:
		v = heapq.heappop(hq)[1]
		seen[v] = True
		for (to, cost) in g[v]:
			if seen[to] == False and dist[v] + cost < dist[to]:
				dist[to] = dist[v] + cost
				heapq.heappush(hq, (dist[to], to))
	return dist

def LIS(b):
	l = [b[0]]
	for i in b:
		if i > l[-1]:
			l += [i]
		else:
			l[bisect.bisect_left(l, i)] = i
	return len(l)

def two(n):
	return len(str(bin(n))) - str(bin(n)).rfind('1') - 1

def yn(b):
	if b:
		print('Yes')
	else:
		print('No')

def op(s):
	print(s)
	return ()
(n, a, b) = input()
x = input()
ans = 0
for i in range(1, n):
	ans += min((x[i] - x[i - 1]) * a, b)
print(ans)


import queue
(n, a, b) = list(map(int, input().split()))
x = list(map(int, input().split()))
vals = [float('inf')] * n
vals[0] = 0
c = queue.Queue()
c.put(1)
while not c.empty():
	d = c.get()
	if d == n:
		continue
	if b + vals[d - 1] < vals[d]:
		vals[d] = b + vals[d - 1]
	if a * (x[d] - x[d - 1]) + vals[d - 1] < vals[d]:
		vals[d] = a * (x[d] - x[d - 1]) + vals[d - 1]
	c.put(d + 1)
print(vals[-1])


(n, a, b) = map(int, input().split())
x = list(map(int, input().split()))
cnt = 0
for (i, j) in zip(x, x[1:]):
	if a * (j - i) < b:
		cnt += a * (j - i)
	else:
		cnt += b
print(cnt)


(N, A, B) = map(int, input().split())
X = list(map(int, input().split()))
dist = [0 for _ in range(N - 1)]
for i in range(N - 1):
	dist[i] = (X[i + 1] - X[i]) * A
cnt = 0
for i in range(N - 1):
	if dist[i] > B:
		cnt += B
	else:
		cnt += dist[i]
print(cnt)


import bisect
import heapq
import itertools
import sys
import math
import random
from collections import Counter, deque, defaultdict
from functools import reduce
from operator import xor
from typing import List
mod = 10 ** 9 + 7
sys.setrecursionlimit(10 ** 9)

def lmi():
	return list(map(int, input().split()))

def main():
	(N, A, B) = lmi()
	X = lmi()
	ans = 0
	for i in range(1, N):
		ans += min((X[i] - X[i - 1]) * A, B)
	print(ans)

def __starting_point():
	main()
__starting_point()