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: #include <bits/stdc++.h>
  using namespace std;
  void __print(int x) { cerr << x; }
  void __print(long x) { cerr << x; }
  void __print(long long x) { cerr << x; }
  void __print(unsigned x) { cerr << x; }
  void __print(unsigned long x) { cerr << x; }
  void __print(unsigned long long x) { cerr << x; }
  void __print(float x) { cerr << x; }
  void __print(double x) { cerr << x; }
  void __print(long double x) { cerr << x; }
  void __print(char x) { cerr << '\'' << x << '\''; }
  void __print(const char* x) { cerr << '\"' << x << '\"'; }
  void __print(const string& x) { cerr << '\"' << x << '\"'; }
  void __print(bool x) { cerr << (x ? "true" : "false"); }
  template <typename T, typename V>
  void __print(const pair<T, V>& x) {
    cerr << '{';
    __print(x.first);
    cerr << ',';
    __print(x.second);
    cerr << '}';
  }
  template <typename T>
  void __print(const T& x) {
    int f = 0;
    cerr << '{';
    for (auto& i : x) cerr << (f++ ? "," : ""), __print(i);
    cerr << "}";
  }
  void _print() { cerr << "]\n"; }
  template <typename T, typename... V>
  void _print(T t, V... v) {
    __print(t);
    if (sizeof...(v)) cerr << ", ";
    _print(v...);
  }
  template <int MOD_>
  struct modnum {
    static constexpr int MOD = MOD_;
    static_assert(MOD_ > 0, "MOD must be positive");
  
   private:
    using ll = long long;
    int v;
    static int minv(int a, int m) {
      a %= m;
      assert(a);
      return a == 1 ? 1 : int(m - ll(minv(m, a)) * ll(m) / a);
    }
  
   public:
    modnum() : v(0) {}
    modnum(ll v_) : v(int(v_ % MOD)) {
      if (v < 0) v += MOD;
    }
    explicit operator int() const { return v; }
    friend std::ostream& operator<<(std::ostream& out, const modnum& n) {
      return out << int(n);
    }
    friend std::istream& operator>>(std::istream& in, modnum& n) {
      ll v_;
      in >> v_;
      n = modnum(v_);
      return in;
    }
    friend bool operator==(const modnum& a, const modnum& b) {
      return a.v == b.v;
    }
    friend bool operator!=(const modnum& a, const modnum& b) {
      return a.v != b.v;
    }
    modnum inv() const {
      modnum res;
      res.v = minv(v, MOD);
      return res;
    }
    friend modnum inv(const modnum& m) { return m.inv(); }
    modnum neg() const {
      modnum res;
      res.v = v ? MOD - v : 0;
      return res;
    }
    friend modnum neg(const modnum& m) { return m.neg(); }
    modnum operator-() const { return neg(); }
    modnum operator+() const { return modnum(*this); }
    modnum& operator++() {
      v++;
      if (v == MOD) v = 0;
      return *this;
    }
    modnum& operator--() {
      if (v == 0) v = MOD;
      v--;
      return *this;
    }
    modnum& operator+=(const modnum& o) {
      v += o.v;
      if (v >= MOD) v -= MOD;
      return *this;
    }
    modnum& operator-=(const modnum& o) {
      v -= o.v;
      if (v < 0) v += MOD;
      return *this;
    }
    modnum& operator*=(const modnum& o) {
      v = int(ll(v) * ll(o.v) % MOD);
      return *this;
    }
    modnum& operator/=(const modnum& o) { return *this *= o.inv(); }
    friend modnum operator++(modnum& a, int) {
      modnum r = a;
      ++a;
      return r;
    }
    friend modnum operator--(modnum& a, int) {
      modnum r = a;
      --a;
      return r;
    }
    friend modnum operator+(const modnum& a, const modnum& b) {
      return modnum(a) += b;
    }
    friend modnum operator-(const modnum& a, const modnum& b) {
      return modnum(a) -= b;
    }
    friend modnum operator*(const modnum& a, const modnum& b) {
      return modnum(a) *= b;
    }
    friend modnum operator/(const modnum& a, const modnum& b) {
      return modnum(a) /= b;
    }
  };
  template <typename T>
  T pow(T a, long long b) {
    assert(b >= 0);
    T r = 1;
    while (b) {
      if (b & 1) r *= a;
      b >>= 1;
      a *= a;
    }
    return r;
  }
  using num = modnum<int(1e9 + 13)>;
  int n;
  long long c[1001];
  vector<long long> y;
  long long intersect(long long a, long long b, long long c, long long d) {
    long long low = max(a, c);
    long long high = min(b, d);
    if (low <= high)
      return high - low + 1;
    else
      return 0;
  }
  int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cin >> n;
    y.push_back(0);
    for (int i = 1; i <= n; i++) {
      cin >> c[i];
      if (i % 2 == 1) {
        y.push_back(y[i - 1] + c[i]);
      } else {
        y.push_back(y[i - 1] - c[i]);
      }
    }
    long long ans = 0;
    for (int i = 1; i <= n; i++)
      if (i % 2 == 1) {
        long long lower_limit = y[i - 1];
        long long upper_limit = y[i] - 1;
        for (int j = i + 1; j <= n; j++)
          if (j % 2 == 0) {
            ans += intersect(lower_limit, upper_limit, y[j], y[j - 1]);
            upper_limit = min(upper_limit, y[j]);
            if (lower_limit > upper_limit) break;
          }
      }
    cout << ans << endl;
    return 0;
  }
  