#include <bits/stdc++.h>
using namespace std;
#define int long long
#define stoi stoll
using ll=long long;
using vi=vector<int>;
using pii=pair<int,int>;
#define ALL(c) begin(c),end(c)
#define RALL(c) rbegin(c),rend(c)
#define ITR(i,b,e) for(auto i=(b);i!=(e);++i)
#define FORE(x,c) for(auto &&x:c)
#define REPF(i,a,n) for(int i=a,i##len=(int)(n);i<i##len;++i)
#define REP(i,n) REPF(i,0,n)
#define REPR(i,n) for(int i=(int)(n);i>=0;--i)
#define SZ(c) ((int)c.size())
#define CONTAIN(c,x) (c.find(x)!=end(c))
#define INSEG(l,x,r) ((l)<=(x)&&(x)<(r))
#define dump(...)
#define pb push_back
#define _ 0
const signed INF_=1001001001; const long long INF=1001001001001001001LL;
const int DX[9]={0,1,0,-1,1,1,-1,-1,0},DY[9]={-1,0,1,0,-1,1,1,-1,0};
template<class T> ostream& operator<<(ostream &os,const vector<T> &v) {
    ITR(i,begin(v),end(v))os<<*i<<(i==end(v)-1?"":" ");return os;}
template<class T> istream& operator>>(istream &is,vector<T> &v) {
    ITR(i,begin(v),end(v)) is>>*i;return is;}
template<class T,class U> istream& operator>>(istream &is, pair<T,U> &p) {
    is>>p.first>>p.second;return is;}
template<class T, class U> bool chmax(T &a,const U &b){return a<b?a=b,1:0;}
template<class T, class U> bool chmin(T &a,const U &b){return a>b?a=b,1:0;}
template <class T> void PSUM(T& c) {partial_sum(begin(c), end(c), begin(c));}
template<class T> using heap=priority_queue<T,vector<T>,greater<T>>;
struct before_main_function {
    before_main_function() {
        cin.tie(0); ios::sync_with_stdio(false);
        cout << setprecision(15) << fixed;
        // #define endl "\n"
    }
} before_main_function;
//------------------8<------------------------------------8<--------------------

template<typename Monoid>
struct SegmentTree {
    using T = typename Monoid::T;
    size_t n;
    vector<T> t;

    void prop_to(std::size_t i) { t[i] = Monoid::op(t[i << 1], t[i << 1 | 1]); }
    SegmentTree(size_t size, const T& v = Monoid::identity()) {
        n = 1;
        while (n < size) n <<= 1;
        t.resize(n << 1, v);
    }
    template <class InputIt>
    SegmentTree(InputIt first, InputIt last) : n(distance(first, last)), t(n << 1, Monoid::identity()) {
        copy(first, last, begin(t) + n);
        for (size_t i = n - 1; i > 0; i--) prop_to(i);
    }
    static T modify_update(const T& a, const T& b) { return b; }
    static T modify_add(const T& a, const T& b) { return a + b; }
    void update(size_t i, const T& v, const function<T(T, T)>& func = modify_update) {
        i += n;
        t[i] = func(t[i], v);
        while (i >>= 1) prop_to(i);
    }
    T query(size_t l, size_t r) {
        T res = Monoid::identity();
        for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
            if (l & 1) res = Monoid::op(res, t[l++]);
            if (r & 1) res = Monoid::op(res, t[--r]);
        }
        return res;
    }
    T get(size_t i) { return t[i + n]; }
};

struct RMQ {
    using T = pii;
    static T op(T a, T b) { return min(a, b); }
    static constexpr T identity() { return {INF, INF}; }
};

struct union_find {
    vector<int> data;
    int comp_num;
    union_find(int size) : data(size, -1), comp_num(size) {}
    void unite(int x, int y) {
        x = root(x); y = root(y);
        if(x != y) {
            if(data[y] < data[x]) swap(x, y);
            data[x] += data[y];
            data[y] = x;
            comp_num--;
        }
    }
    bool same(int x, int y) {
        return root(x) == root(y);
    }
    int root(int x) {
        return data[x] < 0 ? x : (data[x] = root(data[x]));
    }
    int size(int x) {
        return -data[root(x)];
    }
};

signed main() {
    int N, D;
    cin >> N >> D;
    vector<int> A(N);
    cin >> A;
    
    SegmentTree<RMQ> seg_left(N), seg_right(N);
    REP(i, N) {
        seg_left.update(i, pii(-D * i + A[i], i));
        seg_right.update(i, pii(D * i + A[i], i));
    }
    
    int ans = 0;
    union_find uf(N);
    while (uf.comp_num > 1) {
        vector<vector<int>> nodes(N);
        REP(i, N) nodes[uf.root(i)].push_back(i);

        set<pair<int, pii>> edge;

        REP(i, N) {
            if (nodes[i].empty()) continue;
            vector<pii> bkup_left(SZ(nodes[i]));
            vector<pii> bkup_right(SZ(nodes[i]));
            REP(j, SZ(nodes[i])) {
                bkup_left[j] = seg_left.get(nodes[i][j]);
                bkup_right[j] = seg_right.get(nodes[i][j]);
                seg_left.update(nodes[i][j], {INF, INF});
                seg_right.update(nodes[i][j], {INF, INF});
            }
            
            vector<pair<int, pii>> e;
            REP(j, SZ(nodes[i])) {
                int x = nodes[i][j];
                auto left = seg_left.query(0, x);
                auto right = seg_right.query(x + 1, N);
                int L = A[x] + D * x + left.first;
                int R = A[x] - D * x + right.first;
                if (L < R) e.push_back({L, {left.second, x}});
                else e.push_back({R, {x, right.second}});
            }
            sort(ALL(e));
            edge.insert(e[0]);

            REP(j, SZ(nodes[i])) {
                seg_left.update(bkup_left[j].second, bkup_left[j]);
                seg_right.update(bkup_right[j].second, bkup_right[j]);
            }
        }

        FORE(e, edge) {
            dump(e.first, e.second);
            ans += e.first;
            uf.unite(e.second.first, e.second.second);
        }
    }
    cout << ans << endl;
    return (0^_^0);
}



Measured memory_bytes: 43656