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: 
  import sys
  import os
  import math
  from io import BytesIO, IOBase
  from collections import defaultdict,Counter,deque
  
  # input=sys.stdin.readline
  # def print(x):
  #     sys.stdout.write(str(x)+"\n")
  
  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")
  
  # sys.stdout=open("CP1/output.txt",'w')
  # sys.stdin=open("CP1/input.txt",'r')
  
  # mod=pow(10,9)+7
  # t=int(input())
  for i in range(1):
  	# c,d=map(int,input().split())
  	n=int(input())
  	a=list(map(int,input().split()))
  	ans=0
  	for j in range(0,n-1,2):
  		init=a[j]
  		left=0
  		carry=0
  		for k in range(j+1,n):
  			# print(k,left,init,a[k])
  			if k&1:
  				if left:
  					if a[k]<left:
  						left-=a[k]
  					else:
  						c=a[k]-left
  						left=0
  						ans+=carry
  						if c<=init:
  							init-=c
  							ans+=c
  						else:
  							ans+=init
  							break
  				else:
  					if a[k]<=init:
  						init-=a[k]
  						ans+=a[k]
  						carry=1
  					else:
  						ans+=init
  						break
  			else:
  				left+=a[k]
  
  		# print(ans)
  
  	print(ans)
  