#include <bits/stdc++.h>
using namespace std;
#define int long long
const long long LINF=1e18;
template <typename T>
struct SegmentTree{
  using F = function<T(T,T)>;
  int n;  //セグ木の幅
  F f;  //モノイドの作用
  T ti;  //初期値
  vector<T> dat;  //セグ木で使う配列 一番上に使われるのがdat[1] 一番下の段の左端がdat[n]
  SegmentTree(){};
  SegmentTree(F f,T ti):f(f),ti(ti){}  //fがモノイドとしての作用、tiが単位元

  SegmentTree(F f,T ti,int n_):f(f),ti(ti){
    n=1;
    while(n<n_) n<<=1;
    dat.assign(n<<1,ti);
  }

  SegmentTree(F f,T ti,const vector<T> &v):f(f),ti(ti){
    int n_=v.size();
    n=1;
    while(n<n_) n<<=1;
    dat.assign(n<<1,ti);
    for(int i=0;i<n_;i++)dat[n+i]=v[i];
    for(int i=n-1;i;i--)
      dat[i]=f(dat[(i<<1)|0],dat[(i<<1),1]);
  }

  T get(int x){
    return dat[x+n];
  }

  void init(int n_){  //ただの初期化
    n=1;
    while(n<n_) n<<=1;  //nが実際にとる２べきの幅
    dat.assign(n<<1,ti);  //dat配列は幅の２倍あってその全てにtiを代入
  }

  void build(const vector<T> &v){  //vector vに合わせた初期化
    int n_=v.size();
    init(n_);
    for(int i=0;i<n_;i++) dat[n+i]=v[i];  //v[i]を一番子の所に代入
    for(int i=n-1;i;i--)
      dat[i]=f(dat[(i<<1)|0],dat[(i<<1)|1]);  //iの子供は2*i、2*i+1
  }

  void set_val(int k,T x){  //（0-indexedで）kにxを代入
    dat[k+=n]=x;
    while(k>>=1)  //kがどんどん自分の親になっていく、0になったらおしまい
      dat[k]=f(dat[(k<<1)|0],dat[(k<<1)|1]);
  }

  T query(int a,int b){  //[a,b)の範囲のモノイドの作用を返す
    T vl=ti,vr=ti;
    for(int l=a+n,r=b+n;l<r;l>>=1,r>>=1) {
      if(l&1) vl=f(vl,dat[l++]);  //左端を使いたくなるのはブロックが奇数の時
      if(r&1) vr=f(dat[--r],vr);  //右端〃偶数の時（開区間なのでr:奇数で反応）
    }
    return f(vl,vr);
  }

  template<typename C>
  int find(int st,C &check,T &acc,int k,int l,int r){  //dat[k]:[l,r)の間にいるenを返す
    //下のfind用なので先にそっち読むべき
    //accはst~lとかで確定している値
    if(l+1==r){  //答えがちゃんと存在するならこのlが答え
      acc=f(acc,dat[k]);
      return check(acc)?k-n:-1; //入るならk-n(==l)を、入らないなら-1を返す
    }
    int m=(l+r)>>1;  //にぶたんのそれ
    if(m<=st) return find(st,check,acc,(k<<1)|1,m,r);  //mがstより後ろなら明らかにl=m;
    if(st<=l&&!check(f(acc,dat[k]))){  //今見てるk全部でもダメ(mだと足りないのでl=mにする）
      acc=f(acc,dat[k]);  //kは全部accに加えた上で-1を返す
      return -1;
    }
    int vl=find(st,check,acc,(k<<1)|0,l,m);  //まず[l,m)の中にenがいるか探す
    if(~vl) return vl;  //いたならそれを返す(if(~vl)は-1以外にのみ反応する)
    return find(st,check,acc,(k<<1)|1,m,r);  //いなかったら[m,r)の中にenがいるのでそれを返す
    //acc=f(acc,dat[k]);がここで効いてる
  }

  template<typename C>
  int find(int st,C &check){
    //check(f(dat[st]~dat[en-1]))=false,check(f(dat[st]~dat[en]))＝trueとなるenを返す
    T acc=ti;
    return find(st,check,acc,1,0,n);
  }
};
typedef pair<int,int> P;
typedef pair<P,int> PI;
struct UnionFind{
  int num;//連結成分の数
  vector<int> r,p;//そのグループのサイズ,自分の親っぽいやつ
  UnionFind(){}
  UnionFind(int n):num(n),r(n,1),p(n,0){iota(p.begin(),p.end(),0);}

  int find(int x){//どのグループに所属するか
    return (x==p[x]?x:p[x]=find(p[x]));//xがグループの名前と一致するまでxを親にする
  }

  bool same(int x,int y){//同じグループかどうか
    return find(x)==find(y);
  }

  void unite(int x,int y){//xとyを同じグループにする
    x=find(x);y=find(y);//xとyのグループの名前をどっちかが変える
    if(x==y) return;
    if(r[x]<r[y]) swap(x,y);//サイズが大きい方をxとする
    r[x]+=r[y];//yの親をxにする（今までyだったグループ名がxになる）
    p[y]=x;
    num--;
  }

  int size(int x){//グループの大きさ
    return r[find(x)];
  }

  int count() const{//グループの数
    return num;
  }
};

signed main(){
  int n,d;cin>>n>>d;
  vector<P> v(n);
  vector<PI> edge;
  for(int i=0;i<n;i++){
    int a;cin>>a;
    v[i]=P(a,i);
  }
  sort(v.begin(),v.end());
  auto f=[](P a,P b){return min(a,b);};
  SegmentTree<P> segl(f,P(LINF,-1),n),segr(f,P(LINF,-1),n);
  for(int i=0;i<n;i++){
    int ki=v[i].first,idx=v[i].second;
    P p=segl.query(0,idx);
    if(~p.second){
      p.first+=ki-(n-1-idx)*d;
      edge.push_back(PI(p,idx));
    }
    p=segr.query(idx+1,n);
    if(~p.second){
      p.first+=ki-idx*d;
      edge.push_back(PI(p,idx));
    }
    segl.set_val(idx,P(ki+(n-1-idx)*d,idx));
    segr.set_val(idx,P(ki+idx*d,idx));
  }
  UnionFind uf(n);
  sort(edge.begin(),edge.end());
  int ans=0;
  for(auto p:edge){
    int c=p.first.first,u=p.first.second,v=p.second;
    if(uf.same(u,v))continue;
    uf.unite(u,v);
    ans+=c;
  }
  cout<<ans<<endl;
}

/*
解説AC
各iについて自分より規模の小さいものとの辺だけを考えれば充分
その時自分より左側にいるやつのうち、一番コストが小さいものだけ考えれば充分
なぜかというと、左側同士で組んだものの方が自分と組むよりよいため
つまり、自分(v)と左の二つ(l1,l2)を考えた時、max(v-l1,v-l2)>l1-l2　が成り立つ
これはl1,l2の方がvより規模が小さい上、場所も近くなるから
そのため、v-l1とv-l2を両方使うならl1-l2を入れた方がいい
左側の、コストが最小じゃないやつ(L1)1人とだけ組むのもダメ？
->コストが最小のやつをL2とすると、v-L1-L2ならv-L1をv-L2にするべき
　　　　　　　　　　　　　　　　　L2-v-L1ならv-L1をL2-L1にするべき
なのでとにかくダメ

解説は（アルメリアさんのブログに助けられてなんとか）理解できたがどうやって考えればいいんだろう
最小全域木に使われる可能性のある辺を考えて減らしたくなるのはわかる
規模もコストも両方小さい辺の方が絶対に強いって部分が大事
そこからさらに、自分より規模が小さい人たちで同じ側の二つを同時に使うことはないまで行く必要がある
規模とコストのうち片方をソートすると見やすくなるんだけど、
規模をソートすると位置関係が見えづらくなる中で、
セグ木で範囲探索をすることで位置関係を保って検索出来るのがおしゃれ
これかもね
要素が2個あって大変だから片方をソートするのは典型なんだけど、
ソートしたあと一個ずつ自分より下のやつとの関係だけ見ればいい場合はもうひと要素もソート済みとして扱える
それが出来るのはもう片方の要素がセグ木に収まる範囲だからなんだけど

解けなかったけど面白い問題だった
*/


Measured memory_bytes: 34280