#include <bits/stdc++.h>

using namespace std;
typedef long long ll;
typedef long double Double;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)

ll N;
ll D;
vector<ll> A;

struct UnionFind {
    vector<int> data;

    UnionFind(int size) : data(size, -1) {}

    UnionFind() {}

    bool unionSet(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;
            //cout << x << " " << y << endl;
        }
        return x != y;
    }

    bool findSet(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)];
    }
};


UnionFind uf;

set<pair<ll, ll> > S;
map<ll, pair<ll, ll>> mn;

void add(ll x, ll v, ll dsum, ll id) {
    auto p = pair<ll, ll>{v - dsum, id};
    int u = uf.root(id);

    if (mn.count(u)) {
        mn[u] = min(mn[u], p);
    } else {
        mn[u] = p;
    }
    S.insert(p);

}

long long INF = 1e18;

pair<ll, ll> find_min(ll x, ll dsum, ll id) {
    auto it = S.begin();
    while (it != S.end()) {
        if (mn[uf.root(it->second)] != *it) {
            it = S.erase(it);
            continue;
        }
        if (uf.findSet(id, it->second)) {
            ++it;
        } else {
            break;
        }
    }
    if (it == S.end()) return {INF, INF};
    return {it->first + dsum + A[x], it->second};
}

void init() {
    S.clear();
    mn.clear();
}

bool one_step(ll &ans) {
    init();
    vector<pair<ll, ll> > seq1, seq2;

    for (int i = 0; i < A.size(); i++) {
        auto r = find_min(i, i * D, i);
        seq1.push_back(r);
        add(i, A[i], i * D, i);
    }

    init();
    reverse(A.begin(), A.end());
    {
        for (int i = 0; i < A.size(); i++) {
            int id = A.size() - i - 1;
            auto r = find_min(i, i * D, id);
            seq2.emplace_back(r);
            add(i, A[i], i * D, id);
        }
        reverse(seq2.begin(), seq2.end());
    }
    reverse(A.begin(), A.end());

    bool upd = false;
    map<int, pair<ll, pair<ll, ll>>> minv;

    for (int i = 0; i < seq1.size(); i++) {
        auto p = min(seq1[i], seq2[i]);
        if (minv.count(uf.root(i)) == 0 || minv[uf.root(i)].first > p.first) {
            minv[uf.root(i)] = {p.first, {i, p.second}};
        }
    }
    for (auto &&p : minv) {
        if (p.second.first == INF) continue;
        if (uf.unionSet(p.second.second.first, p.second.second.second)) {
            ans += p.second.first;
            upd = true;
        }
    }
    return upd;
}

void fake_solve() {

    uf = UnionFind(N);
    ll ans = 0;
    while (true) {
        if (!one_step(ans)) break;
        //cout << "===" << endl;
    }
    cout << ans << endl;


}

void solve() {
    fake_solve();

//  UnionFind uf(N);
//  int ans = 0;
//  while(true) {
//    vector<pair<int, pair<int, int>>> es[N];
//    for (int i = 0; i < N; i++) {
//      for (int j = 0; j < N; j++) {
//        if (i != j && uf.findSet(i, j) == 0) {
//          es[uf.root(i)].push_back({abs(i - j) * D + A[i] + A[j], {i, j}});
//        }
//      }
//    }
//    bool upd = false;
//    for(int i = 0 ; i < N ; i++){
//      if( uf.root(i) == i ){
//        sort(es[i].begin(), es[i].end());
//        if( es[i].size() > 0 ){
//          ans += es[i].front().first;
//          uf.unionSet(es[i].front().second.first, es[i].front().second.second);
//          cout << es[i].front().second.first << "-"  << es[i].front().second.second << endl;
//          upd = true;
//        }
//      }
//    }
//    cout << "====" << endl;
//    if(!upd) break;
//  }

//  int ans = 0;
//  for(int i = 0 ; i < es.size() ; i++){
//    if( uf.unionSet(es[i].second.first, es[i].second.second)){
//      cout << es[i].second.first << " " << es[i].second.second << endl;
//      ans += es[i].first;
//    }
//  }
//    cout << ans << endl;


    //cout << "No submit" << endl;
}

void input() {
    N = ll();
    scanf("%lld", &N);
//    N = 100000;
    D = ll();
    scanf("%lld", &D);
//    D = 1000;
    A = vector<ll>(N);
    for (int i = 0; i < N; i++) {
        scanf("%lld", &A[i]);
//        A[i] = rand() % 1000;
    }
}

int main() {
    input();
    solve();
    return 0;
}


Measured memory_bytes: 51140