using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace CompetitiveProgCsLib
{
	class MainProg
	{
		static string R => Console.ReadLine();
		static int RI => int.Parse(R);
		static double RD => double.Parse(R);
		static int[] RIs => R.Split(' ').Select(int.Parse).ToArray();
		static double[] RDs => R.Split(' ').Select(double.Parse).ToArray();
		static void Out(object obj) => Console.WriteLine(obj);
		static void OutLine<T>(IEnumerable<T> obj, string separateChar) => Out(String.Join(separateChar, obj));
		static void Outb(bool b) => Out(b ? "Yes" : "No");
		static void OutB(bool b) => Out(b ? "YES" : "NO");
		static bool IsIn(int y, int x, int h, int w) => 0 <= x && x < w && 0 <= y && y < h;
		static T MIN<T>(params T[] args) => args.Min();
		static T MAX<T>(params T[] args) => args.Max();

		static void Main(string[] args)
		{
			var nd = RIs;
			var n = nd[0];
			var d = nd[1];
			var a = RIs;

			var visited = new bool[n];
			var pq = new PriorityQueue<Edge>();
			pq.Push(new Edge(-1, 0, 0));
			long ans = 0;
			while(pq.Length != 0)
			{
				var e = pq.Pop();
				if (visited[e.b]) continue;
				visited[e.b] = true;
				ans += e.w;
				for(int i = 0;i < n;i++)
				{
					if (visited[i]) continue;
					pq.Push(new Edge(e.b, i, Math.Abs(e.b - i) * d + a[i] + a[e.b]));
				}
			}
			Out(ans);
		}

		class Edge : IComparable
		{
			public int a, b;
			public long w;
			public Edge(int A,int B,long W)
			{
				a = A;
				b = B;
				w = W;
			}

			public int CompareTo(object obj)
			{
				return w.CompareTo(((Edge)obj).w);
			}
		}

		/// <summary>
		/// 優先度付きキューを提供する
		/// </summary>
		/// <typeparam name="T"></typeparam>
		public class PriorityQueue<T> where T : IComparable
		{
			#region member
			private List<T> list;
			private bool reverse;
			#endregion

			#region constructor
			/// <summary>
			/// 
			/// </summary>
			/// <param name="isReverse">定義された順序の逆で評価する</param>
			public PriorityQueue(bool isReverse = false)
			{
				list = new List<T>();
				reverse = isReverse;
			}
			#endregion

			#region private method
			private bool compare(T a, T b)
			{
				return reverse ^ a.CompareTo(b) > 0;
			}

			private void swap(int a, int b)
			{
				T tmp = list[a];
				list[a] = list[b];
				list[b] = tmp;
			}
			#endregion

			#region public method
			/// <summary>
			/// 要素を追加する
			/// </summary>
			/// <param name="item">追加する要素</param>
			public void Push(T item)
			{
				if (Length < list.Count) list[Length] = item;
				else list.Add(item);
				var pos = Length++;
				while (pos != 0)
				{
					var parent = (pos + 1) / 2 - 1;
					if (compare(list[pos], list[parent])) break;
					swap(pos, parent);
					pos = parent;
				}
			}

			/// <summary>
			/// 要素を追加する
			/// </summary>
			/// <param name="items">追加する要素の列</param>
			public void Push(IEnumerable<T> items)
			{
				foreach (var item in items)
				{
					Push(item);
				}
			}

			/// <summary>
			/// 値を確認する
			/// </summary>
			/// <returns></returns>
			public T Peek()
			{
				return list[0];
			}

			/// <summary>
			/// 値を取り出す
			/// </summary>
			/// <returns></returns>
			public T Pop()
			{
				var ret = Peek();
				var pos = 0;
				list[0] = list[--Length];
				while (2 * pos + 1 < Length)
				{
					var child = 2 * pos + 1;
					var child_other = 2 * pos + 2;
					if (child_other < Length && compare(list[child], list[child_other]))
					{
						child = child_other;
					}
					if (compare(list[child], list[pos])) break;
					swap(pos, child);
					pos = child;
				}
				return ret;
			}

			/// <summary>
			/// クリアする
			/// </summary>
			public void Clear()
			{
				list.Clear();
			}
			#endregion

			#region property
			/// <summary>
			/// 要素の長さを取得する
			/// </summary>
			public int Length
			{
				get;
				private set;
			}
			#endregion
		}
	}
}
