#include<cstdio>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<vector>
#include<set>
using namespace std;
typedef long long ll;
typedef pair<ll,int> pli;
typedef pair<int,ll> pil;
#define Mp make_pair
const int MAXN = 2e5 + 5;
const int inf = 0x3f3f3f3f;
const ll linf = 0x3f3f3f3f3f3f3f3f;

template<typename T>
void chk_min(T &a,T b){ if(a>b) a=b;}

struct Segment_Tree
{
	int n;
	pli mn[MAXN<<2];
	ll tag[MAXN<<2];
	#define ls(u) ((u)<<1)
	#define rs(u) ((u)<<1|1)
	#define lson(u) ls(u),l,mid
	#define rson(u) rs(u),mid+1,r
	inline void push_up(int u){ mn[u] = min(mn[ls(u)], mn[rs(u)]);}
	inline void push_down(int u)
	{
		if(!tag[u]) return;
		mn[ls(u)].first += tag[u]; tag[ls(u)] += tag[u];
		mn[rs(u)].first += tag[u]; tag[rs(u)] += tag[u];
		tag[u]=0;
	}
	
	void build(int n_,ll a[]){ n=n_; build(1,1,n,a);}
	void update_chg(int q,ll k){ update_chg(1,1,n,q,k);}
	void update_add(int ql,int qr,ll k){ update_add(1,1,n,ql,qr,k);}
	pli query(int ql,int qr){ return query(1,1,n,ql,qr);}
	
	void build(int u,int l,int r,ll a[])
	{
		tag[u]=0;
		if(l==r){ mn[u] = Mp(a[l],l); return;}
		int mid = (l+r)>>1;
		build(lson(u),a);
		build(rson(u),a);
		push_up(u);
	}
	
	void update_chg(int u,int l,int r,int q,ll k)
	{
		if(l==r){ mn[u].first=k; return;}
		push_down(u);
		int mid = (l+r)>>1;
		if(q<=mid) update_chg(lson(u),q,k);
		else update_chg(rson(u),q,k);
		push_up(u);
	}
	
	void update_add(int u,int l,int r,int ql,int qr,ll k)
	{
		if(ql<=l && r<=qr){ mn[u].first+=k; tag[u]+=k; return;}
		push_down(u);
		int mid = (l+r)>>1;
		if(ql<=mid) update_add(lson(u),ql,qr,k);
		if(mid<qr) update_add(rson(u),ql,qr,k);
		push_up(u);
	}
	
	pli query(int u,int l,int r,int ql,int qr)
	{
		if(ql<=l && r<=qr) return mn[u];
		push_down(u);
		int mid = (l+r)>>1;
		pli res = Mp(linf,inf);
		if(ql<=mid) chk_min(res, query(lson(u), ql,qr));
		if(mid<qr) chk_min(res, query(rson(u), ql,qr));
		push_up(u);
		return res;
	}
};

ll a[MAXN],lval[MAXN],rval[MAXN];
ll tmp[MAXN];
Segment_Tree lmn,rmn;
set<pil> lNode,rNode;

int main(void)
{
	int n;
	ll d;
	scanf("%d%lld",&n,&d);
	for(int i=1; i<=n; ++i) scanf("%lld",&a[i]);
	
	for(int i=1; i<=n; ++i) lval[i] = a[i] - d*i;
	for(int i=1; i<=n; ++i) rval[i] = a[i] + d*i;
	
	const ll max_val = 1e16;
	
	for(int i=1; i<=n; ++i) tmp[i] = lval[1] + rval[i];
	tmp[1] = linf;
	lmn.build(n,tmp);
	lNode.insert(Mp(1, lval[1]));
	lNode.insert(Mp(n+1, -max_val));
	
	for(int i=1; i<=n; ++i) tmp[i] = lval[i] + max_val;
	tmp[1] = linf;
	rmn.build(n,tmp);
	rNode.insert(Mp(0, -max_val));
	rNode.insert(Mp(n+1, max_val));
	
	ll ans=0;
	for(int k=1; k<n; ++k)
	{
		pli res = min(lmn.query(1,n), rmn.query(1,n));
		ans += res.first;
		int u = res.second;
		
		lmn.update_chg(u,linf);
		rmn.update_chg(u,linf);
		
		set<pil>::iterator it;
		
		it = --lNode.lower_bound(Mp(u,-linf));
		if(it -> second > lval[u])
		{
			lNode.insert(Mp(u, it -> second));
			
			set<pil>::iterator now, nxt;
			now = nxt = lNode.lower_bound(Mp(u,-linf));
			while(now -> second > lval[u])
			{
				++nxt;
				lmn.update_add(now -> first, nxt -> first - 1, lval[u] - now -> second);
				lNode.erase(now);
				now=nxt;
			}
			
			lNode.insert(Mp(u, lval[u]));
		}
		
		it = rNode.upper_bound(Mp(u,-linf));
		if(it -> second > rval[u])
		{
			rNode.insert(Mp(u, it -> second));
			
			set<pil>::iterator now,nxt;
			now = nxt = rNode.lower_bound(Mp(u, -linf));
			while(now -> second > rval[u])
			{
				--nxt;
				rmn.update_add(nxt -> first + 1, now -> first, rval[u] - now -> second);
				rNode.erase(now);
				now = nxt;
			}
			
			rNode.insert(Mp(u, rval[u]));
		}
	}
	printf("%lld",ans);
	return 0;
}

Measured memory_bytes: 68864