#include<bits/stdc++.h>
using namespace std;
#define maxn 240000
typedef long long LL;
const LL mod = 1000000007;
LL A[maxn], D;
LL mi[2][maxn * 4];
void build(int p, int o, int l, int r){
	if(l == r){
		mi[p][o] = p ? D * l + A[l] : - D * l + A[l];
		return;
	}
	int m = (l + r) >> 1;
	build(p, o * 2, l, m);
	build(p, o * 2 + 1, m + 1, r);
	mi[p][o] = min(mi[p][o * 2], mi[p][o * 2 + 1]);
}
LL ask(int p, int o, int l, int r, int L, int R){
	if(l >= L && r <= R) return mi[p][o];
	int m = (l + r) >> 1;
	LL ret = 1E18;
	if(L <= m) ret = min(ret, ask(p, o * 2, l, m, L, R));
	if(R > m) ret = min(ret, ask(p, o * 2 + 1, m + 1, r, L, R));
	return ret;
}
void update(int p, int o, int l, int r, int i){
	if(l == r) mi[p][o] = 1E18;
	else{
		int m = (l + r) >> 1;
		if(i <= m) update(p, o * 2, l, m, i);
		else update(p, o * 2 + 1, m + 1, r, i);
		mi[p][o] = min(mi[p][o * 2], mi[p][o * 2 + 1]);
	}
}
vector<pair<LL, int> > v;
int main(){
	int N;
	cin >> N >> D;
	LL ans = D * (N - 1);
	for(int i = 1; i <= N; i += 1){
		cin >> A[i];
		ans += A[i] << 1;
	}
	ans -= A[1] + A[N];
	for(int i = 2; i < N; i += 1) v.push_back(make_pair(A[i], i));
	sort(v.begin(), v.end());
	build(0, 1, 1, N);
	build(1, 1, 1, N);
	for(auto p : v){
		int i = p.second;
		LL L = ask(0, 1, 1, N, 1, i - 1) + D * i - A[i];
		LL R = ask(1, 1, 1, N, i + 1, N) - D * i - A[i];
		if(L >= 0 && R >= 0) continue;
		ans += min(L, R);
		update(0, 1, 1, N, i);
		update(1, 1, 1, N, i);
	}
	cout << ans;
}
#include<iostream>
#include<algorithm>
#include<functional>
#include<vector>
#include<queue>
using namespace std;
#define LL long long
#define LP pair<LL, LL>
const LL inf = 1e17;
struct segtree {
	int n = 1;
	vector<LP> node;//cost, place
	void init(int N) {
		node.clear();
		while (N > n) n *= 2;
		node.resize(n * 2, { inf, inf });
	}

	void update(int k, LL x, int a) {

		k += n - 1;
		node[k] = { x, a };
		while (k > 0) {
			k = (k - 1) / 2;
			int l = k * 2 + 1;
			int r = k * 2 + 2;
			if (node[l].first < node[r].first) node[k] = node[l];
			else node[k] = node[r];
		}
	}

	LP mini(int a, int b, int k = 0, int l = 0, int r = -1) {

		if (r < 0) r = n;
		if (b <= l || r <= a) return { inf, inf };
		if (a <= l && r <= b) return node[k];
		LP ln = mini(a, b, k * 2 + 1, l, (l + r) / 2);
		LP rn = mini(a, b, k * 2 + 2, (l + r) / 2, r);
		if (ln.first < rn.first) return ln;
		else return rn;
	}
};

struct edge {
	LL to;
	LL cost;
	bool operator<(const edge &e1) const {
		return e1.cost < cost;
	}
};

int N;
int idx[200010];
LL D;
bool used[200010];
vector<LL> A;
vector<LP> B;
vector<edge> G[200010];

LL prim() {
	priority_queue<edge> pq;
	pq.push(edge{ 0, 0 });
	LL total = 0;
	while (!pq.empty()) {
		edge e = pq.top();
		pq.pop();
		if (!used[e.to]) {
			used[e.to] = true;
			total += e.cost;
			for (auto u : G[e.to]) {
				if (!used[u.to]) pq.push(u);
			}
		}
	}
	return total;
}

void build() {
	segtree seg;
	seg.init(N);

	for (int i = 0; i < N; i++) {
		seg.update(idx[i], A[i] + D * (N - i - 1), idx[i]);
		if (i != 0) {
			LP lp = seg.mini(0, idx[i]);
			if (lp.first == inf) continue;

			lp.first -= D * (N - i - 1) - A[i];
			G[B[lp.second].second].push_back(edge{ i, lp.first });
			G[i].push_back(edge{ B[lp.second].second, lp.first });
		}
	}

	seg.init(N);
	for (int i = N - 1; i >= 0; i--) {
		seg.update(idx[i], A[i] + D * i, idx[i]);
		if (i != N - 1) {
			LP lp = seg.mini(0, idx[i]);
			if (lp.first == inf) continue;

			lp.first -= D * i - A[i];
			G[B[lp.second].second].push_back(edge{ i, lp.first });
			G[i].push_back(edge{ B[lp.second].second, lp.first });
		}
	}
}

void init() {
	cin >> N >> D;
	for (int i = 0; i < N; i++) {
		LP tmp;
		cin >> tmp.first;
		tmp.second = i;
		A.push_back(tmp.first);
		B.push_back(tmp);
	}
	sort(B.begin(), B.end());

	for (int i = 0; i < N; i++) {
		idx[B[i].second] = i;
	}
}

int main() {
	ios::sync_with_stdio(false);
	cin.tie(0);
	init();
	build();
	cout << prim() << endl;
	return 0;
}