    #include <stdio.h>
    #include <limits.h>
    #include <bits/stdc++.h>
    #include <iostream>
    using namespace std;
typedef long long LL;

// A utility function to find the vertex with
// minimum key value, from the set of vertices
// not yet included in MST
LL minKey(LL key[], bool mstSet[], LL V)
    {
// Initialize min value
        LL min = INT_MAX, min_index;

        for (LL v = 0; v < V; v++)
            if (mstSet[v] == false && key[v] < min)
                min = key[v], min_index = v;

        return min_index;
    }


// Function to construct and prLL MST for
// a graph represented using adjacency
// matrix representation
long primMST(vector<LL> A, LL D, LL V) {
        LL graph[V][V];
        for (LL i = 0; i < V; i++) {
            for (LL j = i; j < V; j++) {
                graph[i][j] = abs(i - j) * D + A[i] + A[j];
                graph[j][i] = graph[i][j];
            }
        }
        // Array to store constructed MST
        LL parent[V];
        // Key values used to pick minimum weight edge in cut
        LL key[V];
        // To represent set of vertices not yet included in MST
        bool mstSet[V];

        // Initialize all keys as INFINITE
        for (LL i = 0; i < V; i++)
            key[i] = INT_MAX, mstSet[i] = false;

        // Always include first 1st vertex in MST.
        // Make key 0 so that this vertex is picked as first vertex.
        key[0] = 0;
        parent[0] = -1; // First node is always root of MST

        // The MST will have V vertices
        for (LL count = 0; count < V - 1; count++) {
            // Pick the minimum key vertex from the
            // set of vertices not yet included in MST
            LL u = minKey(key, mstSet, V);

            // Add the picked vertex to the MST Set
            mstSet[u] = true;

            // Update key value and parent index of
            // the adjacent vertices of the picked vertex.
            // Consider only those vertices which are not
            // yet included in MST
            for (LL v = 0; v < V; v++)

                // graph[u][v] is non zero only for adjacent vertices of m
                // mstSet[v] is false for vertices not yet included in MST
                // Update the key only if graph[u][v] is smaller than key[v]
                if (graph[u][v] && mstSet[v] == false && graph[u][v] < key[v])
                    parent[v] = u, key[v] = graph[u][v];
        }

        // prLL the constructed MST
        long c = 0;
        for (LL i = 1; i < V; i++)
        {
            c += graph[i][parent[i]];
        }
        return c;
    }

    // driver program to test above function
    LL main()
    {
      LL N, D;
      cin >> N >> D;
      vector<LL> A(N);
      for (LL i = 0; i < N;i++)
      {
        cin >> A[i];
      }

        cout << primMST(A, D, N);

        return 0;
    }
