output_description: Print the number of ways to write the numbers under the conditions, modulo
  10^9 + 7.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      N M
      A_1 A_2 ... A_{N}
      B_1 B_2 ... B_{M}
attempt: from collections import deque
  import sys
  
  # sys.setrecursionlimit(200000)
  input = sys.stdin.readline
  # n = int(input())
  n, d = map(int, input().split())
  a = list(map(int, input().split()))
  ans = 0
  kore = []
  
  
  class UnionFind:
      def __init__(self, size):
          self.table = [-1 for _ in range(size)]
  
      def find(self, x):
          while self.table[x] >= 0:
              x = self.table[x]
          return x
  
      def union(self, x, y):
          s1 = self.find(x)
          s2 = self.find(y)
          if s1 != s2:
              if self.table[s1] != self.table[s2]:
                  if self.table[s1] < self.table[s2]:
                      self.table[s2] = s1
                  else:
                      self.table[s1] = s2
              else:
                  self.table[s1] += -1
                  self.table[s2] = s1
          return
  
  
  kimeta = UnionFind(n)
  for i in range(n):
      if i > 0:
          kore.append([a[i] + d + a[i - 1], i - 1, i])
      if i < n - 1:
          kore.append([a[i] + d + a[i + 1], i + 1, i])
      for j in range(i + 2, n):
          if a[i] + (j - i) * d < a[j - 1] + d:
              kore.append([a[i] + (j - i) * d + a[j], j, i])
          else:
              break
      for j in range(i - 2, -1, -1):
          if a[i] + (i - j) * d < a[j + 1] + d:
              kore.append([a[i] + (i - j) * d + a[j], j, i])
          else:
              break
  kore.sort()
  for i, j, k in kore:
      if kimeta.find(j) != kimeta.find(k):
          kimeta.union(j, k)
          ans += i
  print(ans)
  
problem_description: Statement
  
  Consider writing each of the integers from 1 to N \times M in a grid with N
  rows and M columns, without duplicates. Takahashi thinks it is not fun enough,
  and he will write the numbers under the following conditions:
  
    * The largest among the values in the i-th row (1 \leq i \leq N) is A_i.
    * The largest among the values in the j-th column (1 \leq j \leq M) is B_j.
  
  For him, find the number of ways to write the numbers under these conditions,
  modulo 10^9 + 7.
samples: [{"input": "2 2\n    4 3\n    3 4", "output": "2\n    \n\n(A_1, A_2) = (4, 3) and (B_1, B_2) = (3, 4). In this case, there are two ways\nto write the numbers, as follows:\n\n  * 1 in (1, 1), 4 in (1, 2), 3 in (2, 1) and 2 in (2, 2).\n  * 2 in (1, 1), 4 in (1, 2), 3 in (2, 1) and 1 in (2, 2).\n\nHere, (i, j) denotes the square at the i-th row and the j-th column.\n\n* * *"}, {"input": "3 3\n    5 9 7\n    3 6 9", "output": "0\n    \n\nSince there is no way to write the numbers under the condition, 0 should be\nprinted.\n\n* * *"}, {"input": "2 2\n    4 4\n    4 4", "output": "0\n    \n\n* * *"}, {"input": "14 13\n    158 167 181 147 178 151 179 182 176 169 180 129 175 168\n    181 150 178 179 167 180 176 169 182 177 175 159 173", "output": "343772227"}]