#pragma region // {{{ by unolight
#include <bits/stdc++.h>
#include <unistd.h>
#pragma GCC diagnostic ignored "-Wunused-result"
#pragma GCC diagnostic ignored "-Wunused-function"
#define SZ(x) ((int)(x).size())
#define ALL(x) begin(x),end(x)
#define RALL(x) rbegin(x),rend(x)
#define REP(i,n) for ( int i=0; i<int(n); i++ )
#define REP1(i,a,b) for ( int i=(a); i<=int(b); i++ )
#define MP make_pair
#define PB push_back
using namespace std;
typedef int64_t LL;
typedef pair<int,int> PII;
typedef vector<int> VI;

namespace { namespace unolight {
// Read Input
template<class T> void _R( T &x ) { cin>>x; }
void _R( int &x ) { scanf("%d",&x); }
void _R( int64_t &x ) { scanf("%" PRId64,&x); }
void _R( double &x ) { scanf("%lf",&x); }
void _R( char &x ) { scanf(" %c",&x); }
void _R( char *x ) { scanf("%s",x); }
void R() {}
template<class T, class... U> void R( T& head, U&... tail ) { _R(head); R(tail...); }
// Write Output
template<class T> void _W( const T &x ) { cout<<x; }
void _W( const int &x ) { printf("%d",x); }
void _W( const int64_t &x ) { printf("%" PRId64,x); }
void _W( const double &x ) { printf("%.16f\n",x); }
void _W( const char &x ) { putchar(x); }
void _W( const char *x ) { printf("%s",x); }
template<class T> void _W( const vector<T> &x ) { for (auto i = x.begin(); i != x.end(); _W(*i++)) if (i != x.cbegin()) putchar(' '); }
void W() {}
template<class T, class... U> void W( const T& head, const U&... tail ) { _W(head); putchar(sizeof...(tail)?' ':'\n'); W(tail...); }

#ifdef UNOLIGHT
#include "dump.hpp"
#else
#define dump(...)
#endif

template<class T> inline bool chmax( T &a, const T &b ) { return b>a ? a=b,true : false; }
template<class T> inline bool chmin( T &a, const T &b ) { return b<a ? a=b,true : false; }
template<class T> using MaxHeap = priority_queue<T>;
template<class T> using MinHeap = priority_queue<T, vector<T>, greater<T>>;
template<class T, class F=less<T>> void sort_uniq( vector<T> &v, F f=F() ) {
    sort(begin(v),end(v),f);
    v.resize(unique(begin(v),end(v))-begin(v));
}
#pragma endregion // }}}

const int N=200010;
int n,D,A[N];
vector<pair<LL,PII>> s;

LL f( int a, int b ) {
    if ( a>b ) swap(a,b);
    return (LL)(b-a)*D + A[a] + A[b];
}

void solve( int l, int r ) {
    if ( l+1==r ) return;
    solve(l,(l+r)/2);
    solve((l+r)/2,r);
    // merge
    // Ai - Di, Aj + Dj
    int m=(l+r)/2;
    int x,y;
    {
        LL mi=1e18;
        for ( int i=l; i<m; i++ ) {
            LL me=(LL)-D*i+A[i];
            if ( chmin(mi,me) ) x=i;
        }
    }
    {
        LL mi=1e18;
        for ( int i=m; i<r; i++ ) {
            LL me=(LL)D*i+A[i];
            if ( chmin(mi,me) ) y=i;
        }
    }
    for ( int i=m; i<r; i++ ) {
        s.push_back({f(x,i), {x,i}});
    }
    for ( int i=l; i<m; i++ ) {
        if ( i!=x ) s.push_back({f(i,y), {i,y}});
    }
}


struct UnionFind {
    int n, num;
    vector<int> sz, par;
    UnionFind() {}
    UnionFind(int n_) : n(n_), num(n_), sz(n_, 1), par(n_, 0) { iota(par.begin(), par.end(), 0); }
    int find(int x) { return x==par[x] ? x : par[x]=find(par[x]); }
    bool same(int x, int y) { return find(x) == find(y); }
    void unite(int x, int y) {
        x = find(x);
        y = find(y);
        if (x == y)
            return;
        if (sz[x] < sz[y]) swap(x, y);
        sz[x] += sz[y];
        par[y] = x;
        num--;
    }
    int size(int x) { return sz[find(x)]; }
    int count() const { return num; }
};

void main() {
    R(n,D);
    REP(i,n) R(A[i]);
    solve(0,n);
    LL ans=0;
    UnionFind uf(n);
    sort(ALL(s));
    REP(i,SZ(s)) {
        LL w=s[i].first;
        int u=s[i].second.first, v=s[i].second.second;
        if ( !uf.same(u,v) ) {
            ans+=w;
            uf.unite(u,v);
        } 
    }

    W(ans);
}

}} // {{{ main
int main() { unolight::main(); return 0; }
// }}}

Measured memory_bytes: 69820