output_description: Print the minimum possible total cost incurred.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      N C
      h_1 h_2 \ldots h_N
attempt: class Lichaotree:
      # 区間は1-indexed
      # min
      def __init__(self, X):
          self.N = len(X)
          self.N0 = 2 ** (self.N - 1).bit_length()
          self.comp = {v: k for k, v in enumerate(X)}
          self.inf = 10**19
          self.X = X + [self.inf] * (self.N0 - self.N)
          self.data = [None] * (2 * self.N0)
          self.size = [0] * self.N0 + [1] * self.N0
          for i in range(self.N0 - 1, 0, -1):
              self.size[i] = 2 * self.size[2 * i]
  
      def f(self, line, x):
          return line[0] * x + line[1]
  
      def _update(self, k, line):
  
          if self.data[k] is None:
              self.data[k] = line
              return
  
          l = k - (1 << (k.bit_length() - 1))
          r = l + self.size[k]
  
          while True:
              if self.data[k] is None:
                  self.data[k] = line
                  return
  
              m = (l + r) // 2
              lx = self.X[l]
              mx = self.X[m]
              rx = self.X[r - 1]
              gl = self.f(self.data[k], lx) > self.f(line, lx)
              gm = self.f(self.data[k], mx) > self.f(line, mx)
              gr = self.f(self.data[k], rx) > self.f(line, rx)
              if gl and gr:
                  self.data[k] = line
                  return
  
              if not gl and not gr:
                  return
  
              if gm:
                  self.data[k], line = line, self.data[k]
                  gl = not gl
  
              if gl:
                  r = m
                  k = 2 * k
              else:
                  l = m
                  k = 2 * k + 1
  
      def query(self, x):
          k = self.comp[x] + self.N0
          s = self.inf
          while k > 0:
              if self.data[k]:
                  s = min(s, self.f(self.data[k], x))
              k = k >> 1
          return s
  
      def addline(self, line):
          self._update(1, line)
  
  
  N, C = map(int, input().split())
  H = list(map(int, input().split()))
  
  T = Lichaotree(H)
  dp = [10**19] * N
  dp[0] = 0
  T.addline((-2 * H[0], H[0] ** 2))
  for i in range(1, N):
      mi = T.query(H[i])
      dp[i] = mi + C + H[i] ** 2
      T.addline((-2 * H[i], H[i] ** 2 + dp[i]))
  print(dp[-1])
  
problem_description: Statement
  
  There are N stones, numbered 1, 2, \ldots, N. For each i (1 \leq i \leq N),
  the height of Stone i is h_i. Here, h_1 < h_2 < \cdots < h_N holds.
  
  There is a frog who is initially on Stone 1. He will repeat the following
  action some number of times to reach Stone N:
  
    * If the frog is currently on Stone i, jump to one of the following: Stone i + 1, i + 2, \ldots, N. Here, a cost of (h_j - h_i)^2 + C is incurred, where j is the stone to land on.
  
  Find the minimum possible total cost incurred before the frog reaches Stone N.
samples: [{"input": "5 6\n    1 2 3 4 5", "output": "20\n    \n\nIf we follow the path 1 \u2192 3 \u2192 5, the total cost incurred would be ((3 - 1)^2 +\n6) + ((5 - 3)^2 + 6) = 20.\n\n* * *"}, {"input": "2 1000000000000\n    500000 1000000", "output": "1250000000000\n    \n\nThe answer may not fit into a 32-bit integer type.\n\n* * *"}, {"input": "8 5\n    1 3 4 5 10 11 12 13", "output": "62\n    \n\nIf we follow the path 1 \u2192 2 \u2192 4 \u2192 5 \u2192 8, the total cost incurred would be ((3\n- 1)^2 + 5) + ((5 - 3)^2 + 5) + ((10 - 5)^2 + 5) + ((13 - 10)^2 + 5) = 62."}]