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 java.util.*;
  import java.io.BufferedReader;
  import java.io.IOException;
  import java.io.InputStreamReader;
  
  public class new1
  {	
  	
  		
  	public static void main (String[] args)
  	{
  
  		Scanner s  = new Scanner(System.in);
  		int t = 1;//s.nextInt(); 
  		for(int i = 0; i < t; i++) {
  			int n = s.nextInt();
  			int[] arr = new int[n + 1];
  			for(int j = 1; j <= n; j++) {
  				arr[j] = s.nextInt();
  			}
  			int[] count  = new int[n + 1];
  			long total = 0;
  			int j = 1;
  			while(j <= n) {
  				
  				if(j % 2 == 1) {
  					j++;
  					continue;
  				}
  				else {
  					int k = j - 1;
  					while(k >= 1 && arr[j] != 0) {
  						
  						if(k % 2 == 1 && arr[k] > 0) {
  							if(arr[k] > arr[j]) {
  								total = total + arr[j];
  								arr[k] = arr[k] - arr[j];
  								arr[j] = 0;
  								count[j] = 1;
  							}
  							else if(arr[k] < arr[j]) {
  								total = total + arr[k] + count[k - 1];
  								arr[j] = arr[j] - arr[k];	
  								arr[k] = 0;
  							}
  							else {
  								total = total + arr[j] + count[k - 1];
  								arr[k] = 0;
  								arr[j] = 0;
  								count[j] = count[k - 1] + 1;
  							}
  						}
  //						System.out.println(k + " " + j + " " + count[j] + " " + total);
  						k--;
  						
  					}
  					
  					
  					
  					
  				}
  						
  			
  			
  			j++;	
  				
  				
  				
  			}
  			System.out.println(total);
  			
  			
  		}
  	}
  }
  
  
  
  
  class FastReader {
     BufferedReader br;
     StringTokenizer st;
     public FastReader() {
         br = new BufferedReader(new InputStreamReader(System.in));
     }
     String next() {
         while (st == null || !st.hasMoreElements()) {
             try {
                 st = new StringTokenizer(br.readLine());
             } catch (IOException e) {
                 e.printStackTrace();
             }
         }
         return st.nextToken();
     }
  
     public int nextInt() {
         return Integer.parseInt(next());
     }
  
     long nextLong() {
         return Long.parseLong(next());
     }
  
     double nextDouble() {
         return Double.parseDouble(next());
     }
  
     String nextLine() {
         String str = "";
         try {
             str = br.readLine();
         } catch (IOException e) {
             e.printStackTrace();
         }
         return str;
  }}