#include <bits/stdc++.h>
using i64 = long long;
using std::cin;
using std::cout;
using std::endl;
struct LazySegmentTree {
  using P = std::pair<i64, int>;
  const P e = {1LL << 60, 1LL << 60};
  std::vector<P> seg;
  std::vector<i64> lazy;
  int sz = 1;
  LazySegmentTree(int n) {
    while (sz < n) sz <<= 1;
    seg.assign(sz * 2 - 1, e);
    lazy.assign(sz * 2 - 1, 0);
  }
  void push(int k) {
    if (k < sz - 1) {
      lazy[2 * k + 1] += lazy[k];
      lazy[2 * k + 2] += lazy[k];
    }
    seg[k].first += lazy[k];
    lazy[k] = 0;
  }
  void update(int k, int x) {
    k += sz - 1;
    seg[k].first = x;
    seg[k].second = k - (sz - 1);
    while (k) {
      k = (k - 1) >> 1;
      seg[k] = std::min(seg[2 * k + 1], seg[2 * k + 2]);
    }
  }
  void add(int a, int b, int k, int l, int r, int x) {
    push(k);
    if (b <= l || r <= a) return;
    if (a <= l && r <= b) {
      lazy[k] += x;
      push(k);
      return;
    }
    add(a, b, 2 * k + 1, l, (l + r) >> 1, x);
    add(a, b, 2 * k + 2, (l + r) >> 1, r, x);
    seg[k] = std::min(seg[2 * k + 1], seg[2 * k + 2]);
  }
  void add(int a, int b, int x) { add(a, b, 0, 0, sz, x); }
  P get(int a, int b, int k, int l, int r) {
    push(k);
    if (b <= l || r <= a) return e;
    if (a <= l && r <= b) return seg[k];
    P L = get(a, b, 2 * k + 1, l, (l + r) >> 1);
    P R = get(a, b, 2 * k + 2, (l + r) >> 1, r);
    return std::min(L, R);
  }
  P get(int a, int b) { return get(a, b, 0, 0, sz); }
  P operator[](int k) { return get(k, k + 1); }
};
struct UnionFind {
  std::vector<int> data;
  UnionFind(int n) { data.assign(n, -1); }
  bool unite(int x, int y) {
    x = find(x);
    y = find(y);
    if (x == y) return false;
    if (data[x] > data[y]) std::swap(x, y);
    data[x] += data[y];
    data[y] = x;
    return true;
  }
  int find(int k) {
    if (data[k] < 0) return k;
    return data[k] = find(data[k]);
  }
};
int main() {
  i64 n, d;
  scanf("%lld%lld", &n, &d);
  std::vector<i64> a(n);
  LazySegmentTree A(n), B(n);
  for (int i = 0; i < n; i++) {
    scanf("%lld", &a[i]);
    A.update(i, a[i]);
    B.update(i, a[i]);
  }
  A.add(0, 1, d);
  std::vector<std::pair<i64, std::pair<int, int>>> edges;
  for (int i = 1; i < n; i++) {
    auto p = A.get(0, i);
    i64 cost = p.first + a[i];
    edges.push_back({cost, {i, p.second}});
    A.add(0, i + 1, d);
  }
  B.add(n - 1, n, d);
  for (int i = n - 2; i >= 0; i--) {
    auto p = B.get(i, n);
    i64 cost = p.first + a[i];
    edges.push_back({cost, {i, p.second}});
    B.add(i, n, d);
  }
  sort(begin(edges), end(edges));
  i64 ans = 0;
  UnionFind uf(n);
  for (auto v : edges) {
    if (uf.unite(v.second.first, v.second.second)) ans += v.first;
  }
  printf("%lld\n", ans);
  return 0;
}
