output_description: Print the minimum number of operations required to achieve the objective.
  
  * * *
input_description: The input is given from Standard Input in the following format:
  
      
      
      N x
      a_1 a_2 ... a_N
attempt: import sys
  import math
  import copy
  import heapq
  from functools import cmp_to_key
  from bisect import bisect_left, bisect_right
  from collections import defaultdict, deque, Counter
  
  sys.setrecursionlimit(1000000)
  
  # input aliases
  input = sys.stdin.readline
  getS = lambda: input().strip()
  getN = lambda: int(input())
  getList = lambda: list(map(int, input().split()))
  getZList = lambda: [int(x) - 1 for x in input().split()]
  
  INF = float("inf")
  MOD = 10**9 + 7
  divide = lambda x: pow(x, MOD - 2, MOD)
  
  
  def nck(n, k, kaijyo):
      return (npk(n, k, kaijyo) * divide(kaijyo[k])) % MOD
  
  
  def npk(n, k, kaijyo):
      if k == 0 or k == n:
          return n % MOD
      return (kaijyo[n] * divide(kaijyo[n - k])) % MOD
  
  
  def fact_and_inv(SIZE):
      inv = [0] * SIZE  # inv[j] = j^{-1} mod MOD
      fac = [0] * SIZE  # fac[j] = j! mod MOD
      finv = [0] * SIZE  # finv[j] = (j!)^{-1} mod MOD
      inv[1] = 1
      fac[0] = fac[1] = 1
      finv[0] = finv[1] = 1
      for i in range(2, SIZE):
          inv[i] = MOD - (MOD // i) * inv[MOD % i] % MOD
          fac[i] = fac[i - 1] * i % MOD
          finv[i] = finv[i - 1] * inv[i] % MOD
  
      return fac, finv
  
  
  def renritsu(A, Y):
      # example 2x + y = 3, x + 3y = 4
      # A = [[2,1], [1,3]])
      # Y = [[3],[4]] または [3,4]
      A = np.matrix(A)
      Y = np.matrix(Y)
      Y = np.reshape(Y, (-1, 1))
      X = np.linalg.solve(A, Y)
  
      # [1.0, 1.0]
      return X.flatten().tolist()[0]
  
  
  class TwoDimGrid:
      # 2次元座標 -> 1次元
      def __init__(self, h, w, wall="#"):
          self.h = h
          self.w = w
          self.size = (h + 2) * (w + 2)
          self.wall = wall
          self.get_grid()
          # self.init_cost()
  
      def get_grid(self):
          grid = [self.wall * (self.w + 2)]
          for i in range(self.h):
              grid.append(self.wall + getS() + self.wall)
  
          grid.append(self.wall * (self.w + 2))
          self.grid = grid
  
      def init_cost(self):
          self.cost = [INF] * self.size
  
      def pos(self, x, y):
          # 壁も含めて0-indexed 元々の座標だけ考えると1-indexed
          return y * (self.w + 2) + x
  
      def getgrid(self, x, y):
          return self.grid[y][x]
  
      def get(self, x, y):
          return self.cost[self.pos(x, y)]
  
      def set(self, x, y, v):
          self.cost[self.pos(x, y)] = v
          return
  
      def show(self):
          for i in range(self.h + 2):
              print(self.cost[(self.w + 2) * i : (self.w + 2) * (i + 1)])
  
      def showsome(self, tgt):
          for t in tgt:
              print(t)
          return
  
      def showsomejoin(self, tgt):
          for t in tgt:
              print("".join(t))
          return
  
      def search(self):
          grid = self.grid
          move = [(0, 1), (0, -1), (1, 0), (-1, 0)]
          move_eight = [
              (0, 1),
              (0, -1),
              (1, 0),
              (-1, 0),
              (1, 1),
              (1, -1),
              (-1, 1),
              (-1, -1),
          ]
          # for i in range(1, self.h+1):
          #     for j in range(1, self.w+1):
          #         cx, cy = j, i
          #         for dx, dy in move_eight:
          #             nx, ny = dx + cx, dy + cy
  
  
  def solve():
      n, x = getList()
      nums = getList()
      ans = 0
      if nums[0] > x:
          ans += nums[0] - x
          nums[0] = x
      for i in range(1, n):
          t = nums[i] + nums[i - 1] - x
          if t > 0:
              ans += t
              nums[i] -= t
  
      print(ans)
  
  
  def main():
      n = getN()
      for _ in range(n):
          solve()
  
      return
  
  
  if __name__ == "__main__":
      # main()
      solve()
  
problem_description: Statement
  
  There are N boxes arranged in a row. Initially, the i-th box from the left
  contains a_i candies.
  
  Snuke can perform the following operation any number of times:
  
    * Choose a box containing at least one candy, and eat one of the candies in the chosen box.
  
  His objective is as follows:
  
    * Any two neighboring boxes contain at most x candies in total.
  
  Find the minimum number of operations required to achieve the objective.
samples: [{"input": "3 3\n    2 2 2", "output": "1\n    \n\nEat one candy in the second box. Then, the number of candies in each box\nbecomes (2, 1, 2).\n\n* * *"}, {"input": "6 1\n    1 6 1 2 0 4", "output": "11\n    \n\nFor example, eat six candies in the second box, two in the fourth box, and\nthree in the sixth box. Then, the number of candies in each box becomes (1, 0,\n1, 0, 0, 1).\n\n* * *"}, {"input": "5 9\n    3 1 4 1 5", "output": "0\n    \n\nThe objective is already achieved without performing operations.\n\n* * *"}, {"input": "2 0\n    5 5", "output": "10\n    \n\nAll the candies need to be eaten."}]