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.io.*;
  import java.util.*;
  
  public class Sol {
  
      final static int LINE_SIZE = 128;
      FastReader in = new FastReader();
      PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out), false);
  
      int n;
      long[] ar;
  
      void solve() throws Exception {
          n = in.nextInt();
          ar = new long[n];
          for (int i = 0; i < n; i++) ar[i] = in.nextLong();
          long total = 0;
          for (int i = 1; i < n; i += 2) {
              long close = ar[i];
              long par = 0;
              boolean end = false;
              for (int j = i - 1; j >= 0; j--) {
                  //out.println(j + " " + i + " " + close + " " + par + " " + total);
                  if (j % 2 == 0) par -= ar[j];
                  else par += ar[j];
                  if (par < 0) {
                      if (end) total++;
                      if (par + close < 0) {
                          total += close;
                          break;
                      } else {
                          total -= par;
                          close += par;
                          par = 0;
                          end = true;
                      }
                  } else if (par == 0) {
                      total++;
                  }
              }
          }
          out.println(total);
      }
  
      void runCases() throws Exception {
          int tt = 1;
          //tt = in.nextInt();
          while (tt-- > 0) {
              solve();
          }
          in.close();
          out.close();
      }
  
      public static void main(String[] args) throws Exception {
          Sol solver = new Sol();
          solver.runCases();
      }
  
      static class Pii implements Comparable<Pii> {
          public int fi, se;
  
          public Pii(int fi, int se) {
              this.fi = fi;
              this.se = se;
          }
  
          public int compareTo(Pii other) {
              if (fi == other.fi) return se - other.se;
              return fi - other.fi;
          }
      }
  
      static class Pll implements Comparable<Pll> {
          public long fi, se;
  
          public Pll(long fi, long se) {
              this.fi = fi;
              this.se = se;
          }
  
          public int compareTo(Pll other) {
              if (fi == other.fi) return se < other.se ? -1 : 1;
              return fi < other.fi ? -1 : 1;
          }
      }
  
      static class Pair<T extends Comparable<T>, U extends Comparable<U>> implements Comparable<Pair<T, U>> {
          T fi;
          U se;
  
          public Pair(T fi, U se) {
              this.fi = fi;
              this.se = se;
          }
  
          public int compareTo(Pair<T, U> other) {
              if (fi == other.fi) return se.compareTo(other.se);
              return fi.compareTo(other.fi);
          }
      }
  
      static class FastReader {
          private final DataInputStream din = new DataInputStream(System.in);
          private final byte[] buffer = new byte[65536];
          private int bufferPointer = 0, bytesRead = 0;
  
          public String readLine() throws Exception {
              byte[] buf = new byte[LINE_SIZE];
              int cnt = 0, c;
              while ((c = read()) != -1) {
                  if (c == '\n') {
                      if (cnt != 0) break;
                      else continue;
                  }
                  buf[cnt++] = (byte)c;
              }
              return new String(buf, 0, cnt);
          }
  
          public int nextInt() throws Exception {
              int ret = 0;
              byte c = read();
              while (c <= ' ') c = read();
              boolean neg = (c == '-');
              if (neg) c = read();
              do {
                  ret = ret * 10 + c - '0';
              } while ((c = read()) >= '0' && c <= '9');
              return neg ? -ret : ret;
          }
  
          public long nextLong() throws Exception {
              long ret = 0;
              byte c = read();
              while (c <= ' ') c = read();
              boolean neg = (c == '-');
              if (neg) c = read();
              do {
                  ret = ret * 10 + c - '0';
              } while ((c = read()) >= '0' && c <= '9');
              return neg ? -ret : ret;
          }
  
          public double nextDouble() throws Exception {
              double ret = 0, div = 1;
              byte c = read();
              while (c <= ' ') c = read();
              boolean neg = (c == '-');
              if (neg) c = read();
              do {
                  ret = ret * 10 + c - '0';
              } while ((c = read()) >= '0' && c <= '9');
              if (c == '.') while ((c = read()) >= '0' && c <= '9') ret += (c - '0') / (div *= 10);
              return neg ? -ret : ret;
          }
  
          private void fillBuffer() throws Exception {
              bytesRead = din.read(buffer, bufferPointer = 0, 65536);
              if (bytesRead == -1) buffer[0] = -1;
          }
  
          private byte read() throws Exception {
              if (bufferPointer == bytesRead) fillBuffer();
              return buffer[bufferPointer++];
          }
  
          public void close() throws Exception {
              din.close();
          }
      }
  }