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 heapq
  import re
  from itertools import permutations
  from bisect import bisect_left, bisect_right
  from collections import Counter, deque
  from fractions import gcd
  from math import factorial, sqrt
  from functools import lru_cache, reduce
  
  INF = 1 << 60
  mod = 1000000007
  sys.setrecursionlimit(10**7)
  input = sys.stdin.readline
  
  
  # UnionFind
  class UnionFind:
      def __init__(self, n):
          self.n = n
          self.parents = [-1] * n
  
      def find(self, x):
          if self.parents[x] < 0:
              return x
          else:
              self.parents[x] = self.find(self.parents[x])
              return self.parents[x]
  
      def union(self, x, y):
          x = self.find(x)
          y = self.find(y)
  
          if x == y:
              return
  
          if self.parents[x] > self.parents[y]:
              x, y = y, x
  
          self.parents[x] += self.parents[y]
          self.parents[y] = x
  
      def size(self, x):
          return -self.parents[self.find(x)]
  
      def same(self, x, y):
          return self.find(x) == self.find(y)
  
      def members(self, x):
          root = self.find(x)
          return [i for i in range(self.n) if self.find(i) == root]
  
      def roots(self):
          return [i for i, x in enumerate(self.parents) if x < 0]
  
      def group_count(self):
          return len(self.roots())
  
      def all_group_members(self):
          return {r: self.members(r) for r in self.roots()}
  
      def __str__(self):
          return "\n".join("{}: {}".format(r, self.members(r)) for r in self.roots())
  
  
  # ダイクストラ
  def dijkstra_heap(s, edge, n):
      # 始点sから各頂点への最短距離
      d = [10**20] * n
      used = [True] * n  # True:未確定
      d[s] = 0
      used[s] = False
      edgelist = []
      for a, b in edge[s]:
          heapq.heappush(edgelist, a * (10**6) + b)
      while len(edgelist):
          minedge = heapq.heappop(edgelist)
          # まだ使われてない頂点の中から最小の距離のものを探す
          if not used[minedge % (10**6)]:
              continue
          v = minedge % (10**6)
          d[v] = minedge // (10**6)
          used[v] = False
          for e in edge[v]:
              if used[e[1]]:
                  heapq.heappush(edgelist, (e[0] + d[v]) * (10**6) + e[1])
      return d
  
  
  # 素因数分解
  def factorization(n):
      arr = []
      temp = n
      for i in range(2, int(-(-(n**0.5) // 1)) + 1):
          if temp % i == 0:
              cnt = 0
              while temp % i == 0:
                  cnt += 1
                  temp //= i
              arr.append([i, cnt])
  
      if temp != 1:
          arr.append([temp, 1])
  
      if arr == []:
          arr.append([n, 1])
  
      return arr
  
  
  # 2数の最小公倍数
  def lcm(x, y):
      return (x * y) // gcd(x, y)
  
  
  # リストの要素の最小公倍数
  def lcm_list(numbers):
      return reduce(lcm, numbers, 1)
  
  
  # リストの要素の最大公約数
  def gcd_list(numbers):
      return reduce(gcd, numbers)
  
  
  # ここから書き始める
  n, x = map(int, input().split())
  a = list(map(int, input().split()))
  ans = 0
  for i in range(1, n):
      if a[i] > x:
          ans += a[i] + a[i - 1] - x
          a[i] -= a[i] + a[i - 1] - x
          a[i] = max(a[i], 0)
      elif a[i] + a[i - 1] > x:
          ans += (a[i] + a[i - 1]) - x
          a[i] = 0
  print(ans)
  
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."}]