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: competition

Starter code:

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 = map(int, input().split())
X = list(map(int, input().split()))

ans = B * (N-1)
tmp = 0
for i in range(N-1):
    tmp += min(A*(X[i+1] - X[i]), B)
ans = min(ans, tmp)
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 = map(int,input().split())
X = list(map(int,input().split()))
n0 = B//A
S = 0
for i in range(N-1):
  if X[i+1] - X[i] <= n0:
    S += (X[i+1] - X[i])*A
  else:
    S += B

print(S)

N,A,B = list(map(int,input().split()))
X = list(map(int,input().split()))
X.sort()

ans = 0

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


#from statistics import median
#import collections
#aa = collections.Counter(a) # list to list || .most_common(2)で最大の2個とりだせるお a[0][0]
from fractions import gcd
from itertools import combinations,permutations,accumulate, product # (string,3) 3回
#from collections import deque
from collections import deque,defaultdict,Counter
import decimal
import re
import math
import bisect
#
#
#
# pythonで無理なときは、pypyでやると正解するかも！！
#
#
# my_round_int = lambda x:np.round((x*2 + 1)//2)
# 四捨五入g
#
# インデックス系
# int min_y = max(0, i - 2), max_y = min(h - 1, i + 2);
# int min_x = max(0, j - 2), max_x = min(w - 1, j + 2);
#
#
import sys
sys.setrecursionlimit(10000000)
mod = 10**9 + 7
#mod = 9982443453
#mod = 998244353
from sys import stdin
readline = stdin.readline
def readInts():
  return list(map(int,readline().split()))
def readTuples():
    return tuple(map(int,readline().split()))
def I():
  return int(readline())
n,a,b = readInts()
X = readInts()
ans = 0
for i in range(1,n):
    ans += min(b, (X[i]-X[i-1])*a)
print(ans)


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()))
ans = 0
for i in range(1, n): ans+=min((x[i]-x[i-1])*a, b)
print(ans)

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)    

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 += (X[i+1]-X[i])*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)


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


N, A, B = LI()
X = LI()
ans = 0
for i in range(N-1):
    ans += min((X[i+1]-X[i])*A, B)
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 = list(map(int, input().split()))
x = list(map(int, input().split()))

ans = 0
for i in range(1, n):
  d = x[i] - x[i - 1]
  if d * a < b:
    ans += d * a
  else:
    ans += b
    
print(ans)


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

N,A,B = list(map(int,input().split()))
X = list(map(int,input().split()))

ans = 0
for i in range(1,N):
  d = X[i] - X[i-1]
  ans += min(d * A, 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)


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 += (X[i+1] - X[i]) * A
    else:
        ans += B

print(ans)

N, A, B = map(int, input().split())

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

print(ans)

#!/usr/bin/env python
# coding: utf-8

# In[1]:


N,A,B = list(map(int, input().split()))
X = list(map(int, input().split()))


# In[2]:


c = 0
for i in range(N-1):
    dist = X[i+1] - X[i]
    if dist*A > B:
        c += B
    else:
        c += dist*A
print(c)


# In[ ]:






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)

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)


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

pin=lst[0]
ans=0

for i in range(1,n):
  ans+=min((lst[i]-lst[i-1])*a,b)
  
print(ans)

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


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

ans = 0
for i in range(n-1):
    dis = x_seq[i+1] - x_seq[i]
    ans += min(dis*a, b)
print(ans)

import sys
sys.setrecursionlimit(10 ** 9)
# input = sys.stdin.readline    ####
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')
# from math import ceil, floor, log2
# from collections import deque, defaultdict
# from itertools import combinations as comb, combinations_with_replacement as comb_w, accumulate, product, permutations
# from heapq import heapify, heappop, heappush
# import numpy as np    # cumsum
# from bisect import bisect_left, bisect_right

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():
    #input data
    import sys
    input = lambda:sys.stdin.readline().strip()
    n,a,b = map(int,input().split())
    x = list(map(int,input().split()))
   
    #solve
    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)

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

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 = 1.0e-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():
	#a = int(input())
	n, a, b = tin()
	#s = input()	
	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
		#input = sys.stdin.readline
			
	ret = main()
	if ret is not None:
		print(ret)
__starting_point()

def main():
    N, A, B = list(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()

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)

N, A, B = map(int, input().split())
X = list(map(int, input().split()))

ans = 0
for i in range(1, N):
  if (X[i]-X[i-1]) * A < B:
    ans += (X[i]-X[i-1]) * A
  else:
    ans += B
print(ans)

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

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):
  # 町(i-1)から町iに行く方法を考えてみよう～～～
  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 = map(int, input().split())
X = list(map(int, input().split()))
ans = 0
for i in range(N-1):
    ans += min(A*(X[i+1]-X[i]), B)
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
        # unite by size
        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)


#coding: utf-8
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)
    # print(tmp)
    ans += tmp
    now = x

print(ans)


import sys
# sys.setrecursionlimit(100000)


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,*X=map(int,open(c:=0).read().split())
for i in range(n-1):c+=min(a*(X[i+1]-X[i]),b)
print(c)

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

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 = list(map(int,input().split()))
X = list(map(int,input().split()))
NewX = []
for i in range(N-1):
  NewX.append((X[i+1]-X[i])*A)
ans = 0
for i in NewX:
  ans+=min(i, B)
print(ans)


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 = map(int,input().split())
X = list(map(int,input().split()))

ans = 0
for i in range(N-1):
    d = X[i+1]-X[i]
    if d * A < B:
        ans += d*A
    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:])))

N, A, B = list(map(int,input().split()))
X = list(map(int,input().split()))

now = X[0]
ans = 0
for x in X:
  ans += min(B, A*(x-now))
  now = x
  
print(ans)


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


3
#coding: utf-8

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]
                else:
                    if 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=list(map(int,input().split()))
x=list(map(int,input().split()))
ans=0
for i in range(1,n):
    ans+=min(b,a*(x[i]-x[i-1]))
print(ans)


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=list(map(int,input().split()))
x=list(map(int,input().split()))
temp=0
for i in range(n-1):
    c=x[i+1]-x[i]
    temp+=min(c*a,b)
print(temp)


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()