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;
  import java.util.StringTokenizer;
  
  
  public class practiceb{
  
      static FastScanner sc;
      static TreeSet<Integer> ans;
      static long[] arr,dp;
      static char[][] board;
      static long mul,mul1;
      static int[] spf;
      static char[] ch;
      static int n,q,m;
      static long k,a,x,c;
      static StringBuilder sb,sb1;
      static long b,sum;
      static Map<Integer,List<Integer>> map;
      static Map<Long,List<Integer>> map2;
      static Map<Long,List<Integer>> map3;
      static Map<Integer,Integer> shortest;
      static Map<Integer,List<Integer>> map1;
      static List<Long> list,list1;
      static int[] count;
  
      // static class Node{
      //     long dist;
      //     Set<Integer> set;
      //     Node(){
      //         this.set = new HashSet<>();
      //     }
      //     Node(int f){
      //         this.dist = f;
      //         this.set = new HashSet<>();
      //     }
      // }
  
      // public static class Lca {
  
      //     int[] depth;
      //     int[] dfs_order;
      //     int cnt;
      //     int[] first;
      //     int[] minPos;
      //     int n;
  
      //     void dfs(List<Integer>[] tree, int u, int d) {
      //         depth[u] = d;
      //         dfs_order[cnt++] = u;
      //         for (int v : tree[u])
      //             if (depth[v] == -1) {
      //                 dfs(tree, v, d + 1);
      //                 dfs_order[cnt++] = u;
      //             }
      //     }
  
      //     void buildTree(int node, int left, int right) {
      //         if (left == right) {
      //             minPos[node] = dfs_order[left];
      //             return;
      //         }
      //         int mid = (left + right) >> 1;
      //         buildTree(2 * node + 1, left, mid);
      //         buildTree(2 * node + 2, mid + 1, right);
      //         minPos[node] = depth[minPos[2 * node + 1]] < depth[minPos[2 * node + 2]] ? minPos[2 * node + 1] : minPos[2 * node + 2];
      //     }
  
      //     public Lca(List<Integer>[] tree, int root) {
      //         int nodes = tree.length;
      //         depth = new int[nodes];
      //         Arrays.fill(depth, -1);
  
      //         n = 2 * nodes - 1;
      //         dfs_order = new int[n];
      //         cnt = 0;
      //         dfs(tree, root, 0);
  
      //         minPos = new int[4 * n];
      //         buildTree(0, 0, n - 1);
  
      //         first = new int[nodes];
      //         Arrays.fill(first, -1);
      //         for (int i = 0; i < dfs_order.length; i++)
      //             if (first[dfs_order[i]] == -1)
      //                 first[dfs_order[i]] = i;
      //     }
  
      //     public int lca(int a, int b) {
      //         return minPos(Math.min(first[a], first[b]), Math.max(first[a], first[b]), 0, 0, n - 1);
      //     }
  
      //     int minPos(int a, int b, int node, int left, int right) {
      //         if (a == left && right == b)
      //             return minPos[node];
      //         int mid = (left + right) >> 1;
      //         if (a <= mid && b > mid) {
      //             int p1 = minPos(a, Math.min(b, mid), 2 * node + 1, left, mid);
      //             int p2 = minPos(Math.max(a, mid + 1), b, 2 * node + 2, mid + 1, right);
      //             return depth[p1] < depth[p2] ? p1 : p2;
      //         } else if (a <= mid) {
      //             return minPos(a, Math.min(b, mid), 2 * node + 1, left, mid);
      //         } else if (b > mid) {
      //             return minPos(Math.max(a, mid + 1), b, 2 * node + 2, mid + 1, right);
      //         } else {
      //             throw new RuntimeException();
      //         }
      //     }
      // }
  
      // private static long dfs(int v, int parent,long ht) {
  
      //     List<Integer> list = map.get(v);
      //     hyt[v] = ht;
  
      //     if(list.size() == 1){
      //         if(!map3.containsKey(ht))
      //             map3.put(ht,new ArrayList<>());
  
      //         map3.get(ht).add(v);
      //         return ht;
  
      //     }
  
      //     long maxl = -1;
      //     for(Integer i : list){
      //         if(i == parent)
      //             continue;
      //         maxl = Math.max(maxl,dfs(i,v,ht+1));
      //     }
  
      //     return maxl;
  
      // }
      // public static int N = 100005;
  
      // long a[N];
      // long sfx[N];
      // long pfx[N];
  
  //    public static boolean f(int width){
  //
  //        // long[] a = new long[n];
  //        long[] sfx = new long[n];
  //        long[] pfx = new long[n];
  
  //        for (int j = 0; j < n; j++){
  //            if (j % width == 0){
  //                pfx[j] = a[j];
  //            }
  //            else pfx[j] = gcd(pfx[j - 1], a[j]);
  //        }
  //        for (int j = n - 2; j >= 0; j--){
  //            if (j % width == width - 1){
  //                sfx[j] = a[j];
  //            }
  //            else sfx[j] = gcd(sfx[j + 1], a[j]);
  //        }
  //
  //        for(int j = 0; j < n - width + 1 ; j++){
  //            if (gcd(sfx[j], pfx[j + width - 1]) >= k) return true;
  //            if (((j % width) == width - 1) && pfx[j] >= k){
  //                return true;
  //            }
  //        }
  //        return false;
  //    }
  
  
      public static void solve() {
  
          long ans = 0;
          int[] close = new int[n];
  
          for(int i = 0 ; i < n ; i++) {
  
              if(i%2 == 1) {
  
                  long closings = arr[i];
  
                  for(int j = i-1 ; j > -1; ) {
  
                      if(arr[j] >= closings) {
                          ans += closings;
                          if(arr[i] > 0)
                              close[i] = j;
                          arr[i] = 0;
                          arr[j] -= closings;
                          closings = 0;
                      }
  
                      else {
                          closings -= arr[j];
                          arr[i] -= arr[j];
                          ans += arr[j];
                          arr[j] = 0;
                      }
  
                      if(j == 0)
                          break;
  
                      if((arr[j] > 0) || (arr[j-1] > 0))
                          break;
  
                      if(arr[j - 1] == 0) {
                          ans += 1;
                          j = close[j-1];
                      }
  
                  }
              }
          }
  
          System.out.println(ans);
  
      }
  
      private static long find(long num, long a) {
  
          String sa = String.valueOf(a);
          String snum = String.valueOf(num);
          char[] chNum = snum.toCharArray();
          char[] cha = sa.toCharArray();
          int curr = 0;
          long op = 0;
  
          for(int i = 0 ; i < chNum.length; i++) {
              while(curr < cha.length && chNum[i] != cha[curr]) {
                  curr += 1;
                  op += 1;
              }
              if(curr >= cha.length)
                  op += 1;
              curr += 1;
          }
  
          if(curr < cha.length)
              op += cha.length-curr;
  
          return op;
  
      }
  
      public static void main(String[] args) {
  
          sc = new FastScanner();
          // Scanner sc = new Scanner(System.in);
          // SpecialSieve(5000000+5);
  //        long num = 1;
  //        list = new ArrayList<>();
  //        for(int i = 0 ; i <= 60 ; i++) {
  //            list.add(num);
  //            num *= 2;
  //        }
  //        int t = sc.nextInt();
           sb = new StringBuilder();
           int t = 1;
          while(t > 0){
  
  //            a = sc.nextLong();
  //            b = sc.nextLong();
  //            c = sc.nextLong();
              n = sc.nextInt();
              // x = sc.nextLong();
              // m = sc.nextInt();
              // mat = new int[2][m];
  
              // for(int i = 0 ; i < 2 ; i++)
              //     for(int j = 0 ; j < m ; j++)
              //         mat[i][j] = sc.nextLong();
  
              // for(int i = 1 ; i <= 15 ; i++){
              //     m = i;
              //     solve();
              // // }
              // board = new char[3][3];
              // for(int i = 0 ; i < 3 ; i++){
              //     String s = sc.next();
              //     for(int j = 0 ; j < 3 ; j++){
              //         board[i][j] = s.charAt(j);
              //     }
              // }
              // x = sc.nextInt();
              // ch = sc.next().toCharArray();
              // q = sc.nextInt();
  //             ch = sc.next().toCharArray();
              arr = new long[n];
              for(int i = 0 ; i < n ; i++)
                  arr[i] = sc.nextLong();
  //
  //            a = new long[n-1];
  //            for(int i = 1 ; i < n ; i++)
  //                a[i-1] = Math.abs(arr[i] - arr[i-1]);
  //
  //            n -= 1;
  
              solve();
              t -= 1;
          }
  //         System.out.print(sb);
  
      }
  
      // Use this instead of Arrays.sort() on an array of ints. Arrays.sort() is n^2
      // worst case since it uses a version of quicksort. Although this would never
      // actually show up in the real world, in codeforces, people can hack, so
      // this is needed.
      static void ruffleSort(long[] a) {
          //ruffle
          int n=a.length;
          Random r=new Random();
          for (int i=0; i<a.length; i++) {
              int oi=r.nextInt(n);long temp=a[i];
              a[i]=a[oi];
              a[oi]=temp;
          }
  
          //then sort
          Arrays.sort(a);
      }
      public static long gcd(long a, long b)
      {
          if (b == 0)
              return a;
  
          return gcd(b, a % b);
  
      }
      public static int log(double n,double base){
  
          if(n == 0 || n == 1)
              return 0;
  
          if(n == base)
              return 1;
  
          double num = Math.log(n);
          double den = Math.log(base);
  
          if(den == 0)
              return 0;
  
          return (int)(num/den);
      }
      public static long mod(long x, long mod)
      {
          long result = x % mod;
          if (result < 0)
          {
              result += mod;
          }
          return result;
      }
  
      // Use this to input code since it is faster than a Scanner
      static class FastScanner {
          BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
          StringTokenizer st=new StringTokenizer("");
          String next() {
              while (!st.hasMoreTokens())
                  try {
                      st=new StringTokenizer(br.readLine());
                  } catch (IOException e) {
                      e.printStackTrace();
                  }
              return st.nextToken();
          }
  
          int nextInt() {
              return Integer.parseInt(next());
          }
          int[] readArray(int n) {
              int[] a=new int[n];
              for (int i=0; i<n; i++) a[i]=nextInt();
              return a;
          }
          long nextLong() {
              return Long.parseLong(next());
          }
      }
  }
  