description: <image>
  
  William has a favorite bracket sequence. Since his favorite sequence is quite big he provided it to you as a sequence of positive integers c_1, c_2, ..., c_n where c_i is the number of consecutive brackets "(" if i is an odd number or the number of consecutive brackets ")" if i is an even number.
  
  For example for a bracket sequence "((())()))" a corresponding sequence of numbers is [3, 2, 1, 3].
  
  You need to find the total number of continuous subsequences (subsegments) [l, r] (l ≤ r) of the original bracket sequence, which are regular bracket sequences.
  
  A bracket sequence is called regular if it is possible to obtain correct arithmetic expression by inserting characters "+" and "1" into this sequence. For example, sequences "(())()", "()" and "(()(()))" are regular, while ")(", "(()" and "(()))(" are not.
  
  Input
  
  The first line contains a single integer n (1 ≤ n ≤ 1000), the size of the compressed sequence.
  
  The second line contains a sequence of integers c_1, c_2, ..., c_n (1 ≤ c_i ≤ 10^9), the compressed sequence.
  
  Output
  
  Output a single integer — the total number of subsegments of the original bracket sequence, which are regular bracket sequences.
  
  It can be proved that the answer fits in the signed 64-bit integer data type.
  
  Examples
  
  Input
  
  
  5
  4 1 2 3 1
  
  
  Output
  
  
  5
  
  
  Input
  
  
  6
  1 3 2 1 2 4
  
  
  Output
  
  
  6
  
  
  Input
  
  
  6
  1 1 1 1 2 2
  
  
  Output
  
  
  7
  
  Note
  
  In the first example a sequence (((()(()))( is described. This bracket sequence contains 5 subsegments which form regular bracket sequences:
  
    1. Subsequence from the 3rd to 10th character: (()(()))
    2. Subsequence from the 4th to 5th character: ()
    3. Subsequence from the 4th to 9th character: ()(())
    4. Subsequence from the 6th to 9th character: (())
    5. Subsequence from the 7th to 8th character: ()
  
  
  
  In the second example a sequence ()))(()(()))) is described.
  
  In the third example a sequence ()()(()) is described.
solution: # ---------------------------iye ha aam zindegi---------------------------------------------
  import math
  import random
  import heapq, bisect
  import sys
  from collections import deque, defaultdict
  from fractions import Fraction
  import sys
  from collections import defaultdict
  mod = 10 ** 9 + 7
  mod1 = 998244353
  
  # ------------------------------warmup----------------------------
  import os
  import sys
  from io import BytesIO, IOBase
  
  BUFSIZE = 8192
  
  
  class FastIO(IOBase):
      newlines = 0
  
      def __init__(self, file):
          self._fd = file.fileno()
          self.buffer = BytesIO()
          self.writable = "x" in file.mode or "r" not in file.mode
          self.write = self.buffer.write if self.writable else None
  
      def read(self):
          while True:
              b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
              if not b:
                  break
              ptr = self.buffer.tell()
              self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
          self.newlines = 0
          return self.buffer.read()
  
      def readline(self):
          while self.newlines == 0:
              b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
              self.newlines = b.count(b"\n") + (not b)
              ptr = self.buffer.tell()
              self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
          self.newlines -= 1
          return self.buffer.readline()
  
      def flush(self):
          if self.writable:
              os.write(self._fd, self.buffer.getvalue())
              self.buffer.truncate(0), self.buffer.seek(0)
  
  
  class IOWrapper(IOBase):
      def __init__(self, file):
          self.buffer = FastIO(file)
          self.flush = self.buffer.flush
          self.writable = self.buffer.writable
          self.write = lambda s: self.buffer.write(s.encode("ascii"))
          self.read = lambda: self.buffer.read().decode("ascii")
          self.readline = lambda: self.buffer.readline().decode("ascii")
  
  
  sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
  input = lambda: sys.stdin.readline().rstrip("\r\n")
  
  
  # -------------------game starts now----------------------------------------------------import math
  class TreeNode:
      def __init__(self, k, v):
          self.key = k
          self.value = v
          self.left = None
          self.right = None
          self.parent = None
          self.height = 1
          self.num_left = 1
          self.num_total = 1
  
  
  class AvlTree:
  
      def __init__(self):
          self._tree = None
  
      def add(self, k, v):
          if not self._tree:
              self._tree = TreeNode(k, v)
              return
          node = self._add(k, v)
          if node:
              self._rebalance(node)
  
      def _add(self, k, v):
          node = self._tree
          while node:
              if k < node.key:
                  if node.left:
                      node = node.left
                  else:
                      node.left = TreeNode(k, v)
                      node.left.parent = node
                      return node.left
              elif node.key < k:
                  if node.right:
                      node = node.right
                  else:
                      node.right = TreeNode(k, v)
                      node.right.parent = node
                      return node.right
              else:
                  node.value = v
                  return
  
      @staticmethod
      def get_height(x):
          return x.height if x else 0
  
      @staticmethod
      def get_num_total(x):
          return x.num_total if x else 0
  
      def _rebalance(self, node):
  
          n = node
          while n:
              lh = self.get_height(n.left)
              rh = self.get_height(n.right)
              n.height = max(lh, rh) + 1
              balance_factor = lh - rh
              n.num_total = 1 + self.get_num_total(n.left) + self.get_num_total(n.right)
              n.num_left = 1 + self.get_num_total(n.left)
  
              if balance_factor > 1:
                  if self.get_height(n.left.left) < self.get_height(n.left.right):
                      self._rotate_left(n.left)
                  self._rotate_right(n)
              elif balance_factor < -1:
                  if self.get_height(n.right.right) < self.get_height(n.right.left):
                      self._rotate_right(n.right)
                  self._rotate_left(n)
              else:
                  n = n.parent
  
      def _remove_one(self, node):
          """
          Side effect!!! Changes node. Node should have exactly one child
          """
          replacement = node.left or node.right
          if node.parent:
              if AvlTree._is_left(node):
                  node.parent.left = replacement
              else:
                  node.parent.right = replacement
              replacement.parent = node.parent
              node.parent = None
          else:
              self._tree = replacement
              replacement.parent = None
          node.left = None
          node.right = None
          node.parent = None
          self._rebalance(replacement)
  
      def _remove_leaf(self, node):
          if node.parent:
              if AvlTree._is_left(node):
                  node.parent.left = None
              else:
                  node.parent.right = None
              self._rebalance(node.parent)
          else:
              self._tree = None
          node.parent = None
          node.left = None
          node.right = None
  
      def remove(self, k):
          node = self._get_node(k)
          if not node:
              return
          if AvlTree._is_leaf(node):
              self._remove_leaf(node)
              return
          if node.left and node.right:
              nxt = AvlTree._get_next(node)
              node.key = nxt.key
              node.value = nxt.value
              if self._is_leaf(nxt):
                  self._remove_leaf(nxt)
              else:
                  self._remove_one(nxt)
              self._rebalance(node)
          else:
              self._remove_one(node)
  
      def get(self, k):
          node = self._get_node(k)
          return node.value if node else -1
  
      def _get_node(self, k):
          if not self._tree:
              return None
          node = self._tree
          while node:
              if k < node.key:
                  node = node.left
              elif node.key < k:
                  node = node.right
              else:
                  return node
          return None
  
      def get_at(self, pos):
          x = pos + 1
          node = self._tree
          while node:
              if x < node.num_left:
                  node = node.left
              elif node.num_left < x:
                  x -= node.num_left
                  node = node.right
              else:
                  return (node.key, node.value)
          raise IndexError("Out of ranges")
  
      @staticmethod
      def _is_left(node):
          return node.parent.left and node.parent.left == node
  
      @staticmethod
      def _is_leaf(node):
          return node.left is None and node.right is None
  
      def _rotate_right(self, node):
          if not node.parent:
              self._tree = node.left
              node.left.parent = None
          elif AvlTree._is_left(node):
              node.parent.left = node.left
              node.left.parent = node.parent
          else:
              node.parent.right = node.left
              node.left.parent = node.parent
          bk = node.left.right
          node.left.right = node
          node.parent = node.left
          node.left = bk
          if bk:
              bk.parent = node
          node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
          node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
          node.num_left = 1 + self.get_num_total(node.left)
  
      def _rotate_left(self, node):
          if not node.parent:
              self._tree = node.right
              node.right.parent = None
          elif AvlTree._is_left(node):
              node.parent.left = node.right
              node.right.parent = node.parent
          else:
              node.parent.right = node.right
              node.right.parent = node.parent
          bk = node.right.left
          node.right.left = node
          node.parent = node.right
          node.right = bk
          if bk:
              bk.parent = node
          node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
          node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
          node.num_left = 1 + self.get_num_total(node.left)
  
      @staticmethod
      def _get_next(node):
          if not node.right:
              return node.parent
          n = node.right
          while n.left:
              n = n.left
          return n
  
  
  # -----------------------------------------------binary seacrh tree---------------------------------------
  class SegmentTree1:
      def __init__(self, data, default=2**51, func=lambda a, b: a & b):
          """initialize the segment tree with data"""
          self._default = default
          self._func = func
          self._len = len(data)
          self._size = _size = 1 << (self._len - 1).bit_length()
  
          self.data = [default] * (2 * _size)
          self.data[_size:_size + self._len] = data
          for i in reversed(range(_size)):
              self.data[i] = func(self.data[i + i], self.data[i + i + 1])
  
      def __delitem__(self, idx):
          self[idx] = self._default
  
      def __getitem__(self, idx):
          return self.data[idx + self._size]
  
      def __setitem__(self, idx, value):
          idx += self._size
          self.data[idx] = value
          idx >>= 1
          while idx:
              self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
              idx >>= 1
  
      def __len__(self):
          return self._len
  
      def query(self, start, stop):
          if start == stop:
              return self.__getitem__(start)
          stop += 1
          start += self._size
          stop += self._size
  
          res = self._default
          while start < stop:
              if start & 1:
                  res = self._func(res, self.data[start])
                  start += 1
              if stop & 1:
                  stop -= 1
                  res = self._func(res, self.data[stop])
              start >>= 1
              stop >>= 1
          return res
  
      def __repr__(self):
          return "SegmentTree({0})".format(self.data)
  
  
  # -------------------game starts now----------------------------------------------------import math
  class SegmentTree:
      def __init__(self, data, default=0, func=lambda a, b: a + b):
          """initialize the segment tree with data"""
          self._default = default
          self._func = func
          self._len = len(data)
          self._size = _size = 1 << (self._len - 1).bit_length()
  
          self.data = [default] * (2 * _size)
          self.data[_size:_size + self._len] = data
          for i in reversed(range(_size)):
              self.data[i] = func(self.data[i + i], self.data[i + i + 1])
  
      def __delitem__(self, idx):
          self[idx] = self._default
  
      def __getitem__(self, idx):
          return self.data[idx + self._size]
  
      def __setitem__(self, idx, value):
          idx += self._size
          self.data[idx] = value
          idx >>= 1
          while idx:
              self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
              idx >>= 1
  
      def __len__(self):
          return self._len
  
      def query(self, start, stop):
          if start == stop:
              return self.__getitem__(start)
          stop += 1
          start += self._size
          stop += self._size
  
          res = self._default
          while start < stop:
              if start & 1:
                  res = self._func(res, self.data[start])
                  start += 1
              if stop & 1:
                  stop -= 1
                  res = self._func(res, self.data[stop])
              start >>= 1
              stop >>= 1
          return res
  
      def __repr__(self):
          return "SegmentTree({0})".format(self.data)
  
  
  # -------------------------------iye ha chutiya zindegi-------------------------------------
  class Factorial:
      def __init__(self, MOD):
          self.MOD = MOD
          self.factorials = [1, 1]
          self.invModulos = [0, 1]
          self.invFactorial_ = [1, 1]
  
      def calc(self, n):
          if n <= -1:
              print("Invalid argument to calculate n!")
              print("n must be non-negative value. But the argument was " + str(n))
              exit()
          if n < len(self.factorials):
              return self.factorials[n]
          nextArr = [0] * (n + 1 - len(self.factorials))
          initialI = len(self.factorials)
          prev = self.factorials[-1]
          m = self.MOD
          for i in range(initialI, n + 1):
              prev = nextArr[i - initialI] = prev * i % m
          self.factorials += nextArr
          return self.factorials[n]
  
      def inv(self, n):
          if n <= -1:
              print("Invalid argument to calculate n^(-1)")
              print("n must be non-negative value. But the argument was " + str(n))
              exit()
          p = self.MOD
          pi = n % p
          if pi < len(self.invModulos):
              return self.invModulos[pi]
          nextArr = [0] * (n + 1 - len(self.invModulos))
          initialI = len(self.invModulos)
          for i in range(initialI, min(p, n + 1)):
              next = -self.invModulos[p % i] * (p // i) % p
              self.invModulos.append(next)
          return self.invModulos[pi]
  
      def invFactorial(self, n):
          if n <= -1:
              print("Invalid argument to calculate (n^(-1))!")
              print("n must be non-negative value. But the argument was " + str(n))
              exit()
          if n < len(self.invFactorial_):
              return self.invFactorial_[n]
          self.inv(n)  # To make sure already calculated n^-1
          nextArr = [0] * (n + 1 - len(self.invFactorial_))
          initialI = len(self.invFactorial_)
          prev = self.invFactorial_[-1]
          p = self.MOD
          for i in range(initialI, n + 1):
              prev = nextArr[i - initialI] = (prev * self.invModulos[i % p]) % p
          self.invFactorial_ += nextArr
          return self.invFactorial_[n]
  
  
  class Combination:
      def __init__(self, MOD):
          self.MOD = MOD
          self.factorial = Factorial(MOD)
  
      def ncr(self, n, k):
          if k < 0 or n < k:
              return 0
          k = min(k, n - k)
          f = self.factorial
          return f.calc(n) * f.invFactorial(max(n - k, k)) * f.invFactorial(min(k, n - k)) % self.MOD
  
  
  # --------------------------------------iye ha combinations ka zindegi---------------------------------
  def powm(a, n, m):
      if a == 1 or n == 0:
          return 1
      if n % 2 == 0:
          s = powm(a, n // 2, m)
          return s * s % m
      else:
          return a * powm(a, n - 1, m) % m
  
  
  # --------------------------------------iye ha power ka zindegi---------------------------------
  def sort_list(list1, list2):
      zipped_pairs = zip(list2, list1)
  
      z = [x for _, x in sorted(zipped_pairs)]
  
      return z
  
  
  # --------------------------------------------------product----------------------------------------
  def product(l):
      por = 1
      for i in range(len(l)):
          por *= l[i]
      return por
  
  
  # --------------------------------------------------binary----------------------------------------
  def binarySearchCount(arr, n, key):
      left = 0
      right = n - 1
  
      count = 0
  
      while (left <= right):
          mid = int((right + left) / 2)
  
          # Check if middle element is
          # less than or equal to key
          if (arr[mid] < key):
              count = mid + 1
              left = mid + 1
  
          # If key is smaller, ignore right half
          else:
              right = mid - 1
  
      return count
  
  
  # --------------------------------------------------binary----------------------------------------
  def countdig(n):
      c = 0
      while (n > 0):
          n //= 10
          c += 1
      return c
  def binary(x, length):
      y = bin(x)[2:]
      return y if len(y) >= length else "0" * (length - len(y)) + y
  
  def countGreater(arr, n, k):
      l = 0
      r = n - 1
  
      # Stores the index of the left most element
      # from the array which is greater than k
      leftGreater = n
  
      # Finds number of elements greater than k
      while (l <= r):
          m = int(l + (r - l) / 2)
          if (arr[m] >= k):
              leftGreater = m
              r = m - 1
  
          # If mid element is less than
          # or equal to k update l
          else:
              l = m + 1
  
      # Return the count of elements
      # greater than k
      return (n - leftGreater)
  
  
  # --------------------------------------------------binary------------------------------------
  for ik in range(1):
      n=int(input())
      l=list(map(int,input().split()))
      ans=0
      maxi=[[-1 for i in range(n)]for j in range(n)]
      diff = [[-1 for i in range(n)] for j in range(n)]
      for i in range(0,n,2):
          c=l[i]
          mi=c
          for j in range(i+1,n):
              if (j-i)%2==1:
                  c-=l[j]
                  maxi[i][j] = mi
                  mi = min(mi, c)
                  diff[i][j]=c
              else:
                  c+=l[j]
      for i in range(0,n,2):
          for j in range(i+1,n,2):
              ma=maxi[i][j]
              if ma<0:
                  continue
              else:
                  k1=l[j]
                  k=l[i]
                  if diff[i][j]<0:
                      k1+=diff[i][j]
                  else:
                      k-=diff[i][j]
                      ma-=diff[i][j]
                  ma1=min(ma+1,k,k1)
                  ans+=max(0,ma1)
      print(ans)