#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <string>
#include <sstream>
#include <complex>
#include <vector>
#include <list>
#include <queue>
#include <deque>
#include <stack>
#include <map>
#include <set>
using namespace std;
 
#define mod 1000000007
#define FOR(x,to) for(int x=0;x<(to);x++)
#define FORR(x,arr) for(auto& x:arr)
#define ALL(a) (a.begin()),(a.end())
#define ZERO(a) memset(a,0,sizeof(a))
#define MINUS(a) memset(a,0xff,sizeof(a))
#define long long long
inline int rei(){int x;cin>>x;return x;}
inline long rel(){long x;cin>>x;return x;}
inline string res(){string x;cin>>x;return x;}
//------------------------------------------------------- 
class Monoid {
public:
    using t = pair<long,int>;
    static t id() {
        return {10000000000000000,-1};
    }
    static t op(const t& l, const t& r) {
        return min(l, r);
    }
};
template< typename M >
class SegmentTree {
	using T = typename M::t;
	const int n;
	vector<T> data;
	int size(int n_) {
        int res = 1;
        while (res < n_) {
			res <<= 1;
		}
        return res;
    }
	public:
    SegmentTree(int n_)
        : n(size(n_)), data(n * 2, M::id()) {}
    SegmentTree(int n_, T v)
        : n(size(n_)), data(n * 2, v) {}
    SegmentTree(const vector<T>& data_)
        : n(size(data_.size())), data(n * 2, M::id()) {
            init(data_);
    }
    void init() {
        for (int i = n - 1; i >= 1; i--) data[i] = Monoid::op(data[i * 2], data[i * 2 + 1]);
    }
    void init(const vector<T>& data_) {
        for (int i = 0; i < (int)data_.size(); i++) data[i + n] = data_[i];
        init();
    }
  	void Update(int k,const T x){
    	k += n;
    	data[k] = x;
    	while(k >>= 1){
      		data[k] = Monoid::op(data[2*k+0],data[2*k+1]);
    	}
  	}
  	T Query(int a,int b){
    	T L = Monoid::id(), R = Monoid::id();
    	for(a += n,b += n+1;a < b;a >>= 1,b >>= 1){
      		if(a & 1) L = Monoid::op(L,data[a++]);
      		if(b & 1) R = Monoid::op(data[--b],R);
    	}
    	return Monoid::op(L,R);
  	}
	T Query(int a){
    	return data[a+n];
  	}
	// //二分探索をやろうとしている
	// int (int v){
    // 	M L;
	// 	int a = 1;
	// 	if(X[1] < v){
	// 		return 0;
	// 	}
	// 	while(a < n){
	// 		if(f(L,X[a*2]) < v){
	// 			L = f(L,X[a*2]);
	// 			a = a*2+1;
	// 		}
	// 		else{
	// 			a = a*2;
	// 		}
	// 	}
    // 	return 0;
  	// }
	// int (int a,M v){
    // 	M L = 0;
	// 	a += n;
	// 	while()
    // 	for(a += n,b += n+1;a < b;a >>= 1,b >>= 1){
    //   		if(a & 1) L = f(L,X[a++]);
    //   		if(b & 1) R = f(X[--b],R);
    // 	}
    // 	return f(L, R);
  	// }
};
long A[200000];
bool Used[199999];
void Calc(){
	int N = rei();
	long D = rel();
	vector<pair<long,int>> VA(N);
	for(int i=0;i<N;i++){
		A[i] = rel();
		VA[i] = {A[i],i};
	}
	SegmentTree<Monoid> Seg(VA);
	long ans = 0;
	int res = N-1;
	while(res){
		pair<long,int> m = Seg.Query(0,N-1);
		Seg.Update(m.second,Monoid::id());
		if(m.second != 0 && !Used[m.second-1]){
			res--;
			ans += Seg.Query(m.second-1).first + m.first + D;
			Used[m.second-1] = true;
			Seg.Update(m.second-1,{min(Seg.Query(m.second-1).first,m.first+D),m.second-1});
		}
		if(m.second != N-1 && !Used[m.second]){
			res--;
			ans += Seg.Query(m.second+1).first + m.first + D;
			Used[m.second] = true;
			Seg.Update(m.second+1,{min(Seg.Query(m.second+1).first,m.first+D),m.second+1});
		}
	}
	cout << ans << endl;
}
int main(int argc,char** argv){
	ios::sync_with_stdio(false), cin.tie(0);
	cout.tie(0); Calc(); return 0;
}

Measured memory_bytes: 13312