#include <bits/stdc++.h>
using namespace std;
template <typename _T>
using pair2 = pair<_T, _T>;
template <typename _T>
using pair3 = pair<pair<_T, _T>, _T>;
template <typename _T>
using pair4 = pair<pair<_T, _T>, pair<_T, _T>>;
template <typename _T>
using priq = priority_queue<_T>;
template <typename _T>
using qrip = priority_queue<_T, vector<_T>, greater<_T>>;
const long double pi = acosl(-1);
const int Inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3fll;
const int dx[] = {1, 0, -1, 0, 1, 1, -1, -1},
          dy[] = {0, 1, 0, -1, 1, -1, 1, -1};
unsigned Rand() { return rand() * 32768 + rand(); }
int rand(int a, int b) { return Rand() % (b - a + 1) + a; }
template <typename _T>
inline _T chmin(_T &a, _T b) {
  return a > b ? (a = b) : a;
}
template <typename _T>
inline _T chmax(_T &a, _T b) {
  return a < b ? (a = b) : a;
}
template <typename _T, int len>
struct BIT {
  _T dt[len];
  inline void add(int a, _T x) {
    while (a < len) {
      dt[a] += x;
      a += a & -a;
    }
  }
  inline void add(int l, int r, _T x) {
    add(l, x);
    add(r + 1, -x);
  }
  inline _T get(int a) {
    _T ans = 0;
    while (a) {
      ans += dt[a];
      a -= a & -a;
    }
    return ans;
  }
  inline _T get(int l, int r) { return get(r) - get(l - 1); }
};
template <typename _T, int len>
struct segbit {
  _T dt[2][len];
  inline void add(int a, _T x) {
    int b = a;
    while (a < len) {
      dt[0][a] += x;
      dt[1][a] += x * b;
      a += a & -a;
    }
  }
  inline void add(int l, int r, _T x) {
    add(l, x);
    add(r + 1, -x);
  }
  inline _T sum(int a) {
    _T ans = 0;
    int b = a;
    while (a) {
      ans += (b + 1) * dt[0][a] - dt[1][a];
      a -= a & -a;
    }
    return ans;
  }
  inline _T sum(int l, int r) { return sum(r) - sum(l - 1); }
};
struct fastIO {
  inline fastIO operator>>(int &num) {
    num = 0;
    char c = getchar();
    while (c != '-' && (c < '0' || c > '9')) c = getchar();
    bool foo = 0;
    if (c == '-') {
      foo = 1;
      c = getchar();
    }
    while (c >= '0' && c <= '9') {
      num = (num << 3) + (num << 1) + c - '0';
      c = getchar();
    }
    if (foo) num = -num;
    return *this;
  }
  inline fastIO operator>>(long long &num) {
    num = 0;
    char c = getchar();
    while (c != '-' && (c < '0' || c > '9')) c = getchar();
    bool foo = 0;
    if (c == '-') {
      foo = 1;
      c = getchar();
    }
    while (c >= '0' && c <= '9') {
      num = (num << 3) + (num << 1) + c - '0';
      c = getchar();
    }
    if (foo) num = -num;
    return *this;
  }
  inline fastIO operator>>(float &num) {
    scanf("%f", &num);
    return *this;
  }
  inline fastIO operator>>(double &num) {
    scanf("%lf", &num);
    return *this;
  }
  inline fastIO operator>>(long double &num) {
    scanf("%Lf", &num);
    return *this;
  }
  inline fastIO operator>>(char &num) {
    num = getchar();
    while (num == ' ' || num == '\n') num = getchar();
    return *this;
  }
  inline fastIO operator>>(char *num) {
    int cnt = 0;
    char c = getchar();
    while (c == ' ' || c == '\n') c = getchar();
    while (c != ' ' && c != '\n') {
      num[cnt++] = c;
      c = getchar();
    }
    num[cnt] = 0;
    return *this;
  }
  inline fastIO operator>>(string &num) {
    cin >> num;
    return *this;
  }
  inline void printInt(const int &num) {
    if (num < 10) {
      putchar(num + '0');
      return;
    }
    printInt(num / 10);
    putchar((num % 10) + '0');
  }
  inline void printll(const long long &num) {
    if (num < 10) {
      putchar(num + '0');
      return;
    }
    printll(num / 10);
    putchar((num % 10) + '0');
  }
  inline fastIO operator<<(const int &num) {
    if (num < 0)
      putchar('-'), printInt(-num);
    else
      printInt(num);
    return *this;
  }
  inline fastIO operator<<(const long long &num) {
    if (num < 0)
      putchar('-'), printll(-num);
    else
      printll(num);
    return *this;
  }
  inline fastIO operator<<(const float &num) {
    printf("%.10f", num);
    return *this;
  }
  inline fastIO operator<<(const double &num) {
    printf("%.16lf", num);
    return *this;
  }
  inline fastIO operator<<(const long double &num) {
    printf("%.20Lf", num);
    return *this;
  }
  inline fastIO operator<<(const char &num) {
    putchar(num);
    return *this;
  }
  inline fastIO operator<<(const char *num) {
    for (int i = 0; num[i]; i++) putchar(num[i]);
    return *this;
  }
  inline fastIO operator<<(const string &num) {
    cout << num;
    return *this;
  }
  template <typename _T>
  inline fastIO operator<<(const vector<_T> &vec) {
    printf("{ ");
    for (__typeof((vec).begin()) i = (vec).begin(), _e_D_ = (vec).end();
         i != _e_D_; i++)
      operator<<(*i) << ' ';
    printf("}");
    return *this;
  }
} fio;
const long double eps = 1e-10;
struct point {
  long double x, y;
  long double ang;
  point() {}
  point(long double x, long double y) : x(x), y(y) { ang = atan2l(y, x); }
  inline point operator=(const point &pt) {
    x = pt.x;
    y = pt.y;
    return *this;
  }
  inline point operator-() const { return point(-x, -y); }
  inline point operator+(const point &pt) const {
    return point(x + pt.x, y + pt.y);
  }
  inline point operator-(const point &pt) const {
    return point(x - pt.x, y - pt.y);
  }
  inline point operator*(const long double &a) const {
    return point(x * a, y * a);
  }
  inline point operator/(const long double &a) const {
    return point(x / a, y / a);
  }
  inline point operator^(const long double &ang) const {
    return point(x * cosl(ang) - y * sinl(ang), x * sinl(ang) + y * cosl(ang));
  }
  inline point operator+=(const point &pt) {
    return *this = point(x + pt.x, y + pt.y);
  }
  inline point operator-=(const point &pt) {
    return *this = point(x - pt.x, y - pt.y);
  }
  inline point operator*=(const long double &a) {
    return *this = point(x * a, y * a);
  }
  inline point operator/=(const long double &a) {
    return *this = point(x / a, y / a);
  }
  inline point operator^=(const long double &ang) {
    return *this = point(x * cosl(ang) - y * sinl(ang),
                         x * sinl(ang) + y * cosl(ang));
  }
  inline long double operator*(const point &pt) const {
    return x * pt.x + y * pt.y;
  }
  inline long double operator%(const point &pt) const {
    return x * pt.y - y * pt.x;
  }
  inline long double length() const { return x * x + y * y; }
  inline long double size() const { return sqrtl(x * x + y * y); }
  inline long double operator^(const point &pt) const {
    return acosl(*this * pt) / length() / pt.length();
  }
  inline long double getangle() { return ang = atan2l(y, x); }
  inline long double angle() const { return atan2l(y, x); }
  inline bool operator<(const point &p) const { return ang < p.ang; }
};
inline bool xsmaller(const point &x, const point &y) {
  return fabs(x.x - y.x) < 1e-10 ? x.y < y.y : x.x < y.x;
}
inline bool ysmaller(const point &x, const point &y) {
  return fabs(x.y - y.y) < 1e-10 ? x.x < y.x : x.y < y.y;
}
struct line {
  point a, b;
  line() {}
  line(point a, point b) : a(a), b(b) {}
};
point intersect(line x, line y) {
  point p1 = x.a, v1 = x.b - x.a;
  point p2 = y.a, v2 = y.b - y.a;
  return p1 + v1 * (((p2 - p1) % v2) / (v1 % v2));
}
const int jt = 998244353;
inline int &Add(int &a, int b) {
  a += b;
  if (a > jt) {
    a -= jt;
  }
  if (a < 0) {
    a += jt;
  }
  return a;
}
inline int &Sub(int &a, int b) {
  a -= b;
  if (a > jt) {
    a -= jt;
  }
  if (a < 0) {
    a += jt;
  }
  return a;
}
inline int &Mul(int &a, int b) {
  a = 1ll * a * b % jt;
  if (a < 0) {
    a += jt;
  }
  return a;
}
inline int Jar(int a, int b) {
  a += b;
  if (a > jt) {
    a -= jt;
  }
  if (a < 0) {
    a += jt;
  }
  return a;
}
inline int Jan(int a, int b) {
  a -= b;
  if (a > jt) {
    a -= jt;
  }
  if (a < 0) {
    a += jt;
  }
  return a;
}
inline int Churn(int a, int b) {
  a = 1ll * a * b % jt;
  if (a < 0) {
    a += jt;
  }
  return a;
}
inline int ksmii(int a, int b = jt - 2) {
  if (b < 0) {
    return ksmii(ksmii(a), -b);
  }
  if (!b) {
    return 1;
  }
  int x = ksmii(a, b >> 1);
  x = 1ll * x * x % jt;
  if (b & 1) x = 1ll * x * a % jt;
  return x;
}
template <int len>
struct bitmod {
  int dt[len];
  inline void add(int a, int x) {
    while (a < len) {
      dt[a] = (dt[a] + x) % jt;
      a += a & -a;
    }
  }
  inline void add(int l, int r, int x) {
    add(l, x % jt);
    add(r + 1, jt - x % jt);
  }
  inline int get(int a) {
    int ans = 0;
    while (a) {
      ans = (ans + dt[a]) % jt;
      a -= a & -a;
    }
    return ans;
  }
  inline int get(int l, int r) { return (get(r) - get(l - 1) + jt) % jt; }
};
template <int len>
struct DSU {
  int fa[len], sz[len];
  DSU() {
    for (int i = 0; i < (len); i++) fa[i] = i, sz[i] = 1;
  }
  void init() {
    for (int i = 0; i < (len); i++) fa[i] = i, sz[i] = 1;
  }
  int root(int x) { return fa[x] == x ? x : (fa[x] = root(fa[x])); }
  bool conn(int a, int b) {
    a = root(a);
    b = root(b);
    if (a == b) return 0;
    fa[a] = b;
    sz[b] += sz[a];
    return 1;
  }
};
template <typename _T>
inline _T qp(_T a, int b) {
  if (!b) {
    return 1;
  }
  _T x = qp(a, b >> 1);
  x = x * x;
  if (b & 1) {
    x = x * a;
  }
  return x;
}
template <int R, int C = R>
struct matrix {
  int mat[R][C];
  int *operator[](int x) { return mat[x]; }
  matrix() {
    for (int i = 0; i < (R); i++)
      for (int j = 0; j < (C); j++) mat[i][j] = 0;
  }
  matrix(int x) {
    for (int i = 0; i < (R); i++)
      for (int j = 0; j < (C); j++) mat[i][j] = (i == j ? x : 0);
  }
  matrix<R, C> operator+(const matrix<R, C> m) {
    matrix<R, C> ans;
    for (int i = 0; i < (R); i++)
      for (int j = 0; j < (C); j++)
        ans.mat[i][j] = (mat[i][j] + m.mat[i][j]) % jt;
    return ans;
  }
  template <int D>
  matrix<R, D> operator*(const matrix<C, D> m) {
    matrix<R, D> ans;
    for (int i = 0; i < (R); i++)
      for (int j = 0; j < (C); j++)
        for (int k = 0; k < (D); k++)
          ans.mat[i][k] =
              (ans.mat[i][k] + ((long long)mat[i][j]) * m.mat[j][k]) % jt;
    return ans;
  }
  matrix<R, C> operator+=(const matrix<R, C> m) {
    matrix<R, C> ans;
    for (int i = 0; i < (R); i++)
      for (int j = 0; j < (C); j++)
        ans.mat[i][j] = (mat[i][j] + m.mat[i][j]) % jt;
    return ans;
  }
  matrix<R, C> operator-=(const matrix<R, C> m) {
    matrix<R, C> ans;
    for (int i = 0; i < (R); i++)
      for (int j = 0; j < (C); j++)
        ans.mat[i][j] = (mat[i][j] - m.mat[i][j] + jt) % jt;
    return ans;
  }
  void debug() {
    for (int i = 0; i < (R); i++) {
      for (int j = 0; j < (C); j++)
        if (0) cout << mat[i][j] << ' ';
      if (0) cout << endl;
    }
    if (0) cout << endl;
  }
};
DSU<200005> dsu;
int n, d;
int a[200005];
vector<int> vs[200005];
const int N = 1 << 18;
struct Segtree {
  pair2<long long> dt[N << 1];
  void change(int to, long long val) {
    int now = to + N;
    dt[now] = make_pair(val, to);
    now >>= 1;
    while (now) {
      dt[now] = min(dt[now << 1], dt[now << 1 | 1]);
      now >>= 1;
    }
  }
  pair2<long long> qmin(int l, int r, int now = 1, int nl = 0, int nr = N - 1) {
    if (nl >= l && nr <= r) {
      return dt[now];
    }
    if (nl > r || nr < l) {
      return make_pair(INF, INF);
    }
    int m = (nl + nr) >> 1;
    return min(qmin(l, r, now << 1, nl, m),
               qmin(l, r, now << 1 | 1, m + 1, nr));
  }
} seg1, seg2;
int main() {
  fio >> n >> d;
  for (int i = 1; i <= (n); i++) {
    fio >> a[i];
  }
  for (int i = 1; i <= (n); i++) {
    vs[i].push_back(i);
  }
  memset(seg1.dt, 0x3f, sizeof(seg1.dt));
  memset(seg2.dt, 0x3f, sizeof(seg2.dt));
  dsu.init();
  for (int i = 1; i <= (n); i++) {
    seg1.change(i, a[i] - 1ll * i * d);
    seg2.change(i, a[i] + 1ll * i * d);
  }
  long long ans = 0;
  while (dsu.sz[dsu.root(1)] < n) {
    vector<pair<pair2<int>, long long>> egs;
    for (int i = 1; i <= (n); i++) {
      if (dsu.root(i) == i) {
        pair2<int> eg = make_pair(-1, -1);
        long long minx = INF;
        for (int j : vs[i]) {
          seg1.change(j, INF);
          seg2.change(j, INF);
        }
        for (int j : vs[i]) {
          pair2<long long> p = seg1.qmin(1, j);
          long long val = p.first + a[j] + (long long)j * d;
          if (val < minx) {
            minx = val;
            eg = make_pair(j, p.second);
          }
          p = seg2.qmin(j + 1, n);
          val = p.first + a[j] - (long long)j * d;
          if (val < minx) {
            minx = val;
            eg = make_pair(j, p.second);
          }
        }
        for (int j : vs[i]) {
          seg1.change(j, a[j] - (long long)j * d);
          seg2.change(j, a[j] + (long long)j * d);
        }
        egs.emplace_back(eg, minx);
      }
    }
    for (auto i : egs) {
      int ri = dsu.root(i.first.first), rj = dsu.root(i.first.second);
      if (dsu.conn(ri, rj)) {
        ans += i.second;
        for (int j : vs[ri]) {
          vs[rj].push_back(j);
        }
        vs[ri].clear();
      }
    }
  }
  fio << ans << '\n';
  return 0;
}
