A sequence a0, a1, ..., at - 1 is called increasing if ai - 1 < ai for each i: 0 < i < t.

You are given a sequence b0, b1, ..., bn - 1 and a positive integer d. In each move you may choose one element of the given sequence and add d to it. What is the least number of moves required to make the given sequence increasing?

Input

The first line of the input contains two integer numbers n and d (2 ≤ n ≤ 2000, 1 ≤ d ≤ 106). The second line contains space separated sequence b0, b1, ..., bn - 1 (1 ≤ bi ≤ 106).

Output

Output the minimal number of moves needed to make the sequence increasing.

Examples

Input

4 2
1 3 3 2


Output

3
// package main;
import java.io.*;
import java.math.*;
import   java.util.*;;
/**
* Built using CHelper plug-in
* Actual solution is at the top
* @author Togrul Gasimov
*/
public class Main {
  public static void main(String[] args) {
      InputStream inputStream = System.in;
      OutputStream outputStream = System.out;
      FastScanner scan = new FastScanner(inputStream);
      FastPrinter out = new FastPrinter(outputStream);
      TaskD solver = new TaskD();
      solver.solve(1, scan, out);
      out.close();
  }
}

class TaskD {

   static boolean f(String s, String a, String b){
	   if(s.indexOf(a) != -1 && s.indexOf(b , s.indexOf(a) + a.length()) != -1){
		   return true;
	   }
	   
	   return false;
   }
 

  static int gcd(int m, int n){
	  if(m < n)return gcd(n, m);
	  else if(m % n == 0)return n;
	  else return gcd(n, m % n);
  }
  public void solve(int testNumber, FastScanner scan, FastPrinter out) {
       
	 int n = scan.nextInt(), d = scan.nextInt();
	 int[] a = new int[2001];
	 
	 for(int i =1; i <= n; i++){
		 a[i] = scan.nextInt();
	 }
	 int ans = 0;
	  for(int i = 1; i <= n - 1; i++){
		  
		  if(a[i] >= a[i + 1]){
			 int dif = a[i] - a[i + 1];
			  ans += dif / d + 1;
			  a[i + 1] += (dif / d + 1) * d;
		  }
		  
	  }
   
	  /*for(int i = 1; i <= n; i++){
		  out.print(a[i] + " ");
		  }*/
	  out.println(ans);
}
}


class FastScanner extends BufferedReader {

  public FastScanner(InputStream is) {
      super(new InputStreamReader(is));
  }

  public int read() {
      try {
          int ret = super.read();
//            if (isEOF && ret < 0) {
//                throw new InputMismatchException();
//            }
//            isEOF = ret == -1;
          return ret;
      } catch (IOException e) {
          throw new InputMismatchException();
      }
  }

  public String next() {
      StringBuilder sb = new StringBuilder();
      int c = read();
      while (isWhiteSpace(c)) {
          c = read();
      }
      if (c < 0) {
          return null;
      }
      while (c >= 0 && !isWhiteSpace(c)) {
          sb.appendCodePoint(c);
          c = read();
      }
      return sb.toString();
  }

  static boolean isWhiteSpace(int c) {
      return c >= 0 && c <= 32;
  }

  public int nextInt() {
      int c = read();
      while (isWhiteSpace(c)) {
          c = read();
      }
      int sgn = 1;
      if (c == '-') {
          sgn = -1;
          c = read();
      }
      int ret = 0;
      while (c >= 0 && !isWhiteSpace(c)) {
          if (c < '0' || c > '9') {
              throw new NumberFormatException("digit expected " + (char) c
                      + " found");
          }
          ret = ret * 10 + c - '0';
          c = read();
      }
      return ret * sgn;
  }

  public long nextLong() {
      return Long.parseLong(next());
  }

  public String readLine() {
      try {
          return super.readLine();
      } catch (IOException e) {
          return null;
      }
  }

  }

class FastPrinter extends PrintWriter {

  public FastPrinter(OutputStream out) {
      super(out);
  }

  public FastPrinter(Writer out) {
      super(out);
  }


}