#include <bits/stdc++.h>
using namespace std;
#define debug(fmt, ...) \
  fprintf(stderr, "[%d] " fmt "\n", __LINE__, ##__VA_ARGS__)
template <class _Tx, class _Ty>
inline void chkmin(_Tx& x, const _Ty& y) {
  x = min<common_type_t<_Tx, _Ty>>(x, y);
}
template <class _Tx, class _Ty>
inline void chkmax(_Tx& x, const _Ty& y) {
  x = max<common_type_t<_Tx, _Ty>>(x, y);
}
using ll = long long;
using ull = unsigned long long;
using i128 = __int128_t;
using u128 = __uint128_t;
bool Mbe;
constexpr int N = 10, inf = 2e3 + 10;
int n, lmt;
ll div_f(ll n, ll d) {
  if (d < 0) n = -n, d = -d;
  return n >= 0 ? n / d : (n - d + 1) / d;
}
ll div_c(ll n, ll d) {
  if (d < 0) n = -n, d = -d;
  return n >= 0 ? (n + d - 1) / d : n / d;
}
struct point {
  int x, y;
  point& operator+=(const point& rhs) {
    return x += rhs.x, y += rhs.y, *this;
  }
  point& operator-=(const point& rhs) {
    return x -= rhs.x, y -= rhs.y, *this;
  }
  point& operator*=(int k) {
    return x *= k, y *= k, *this;
  }
  friend point operator+(point lhs, const point& rhs) {
    return lhs += rhs;
  }
  friend point operator-(point lhs, const point& rhs) {
    return lhs -= rhs;
  }
  friend point operator*(point lhs, int rhs) {
    return lhs *= rhs;
  }
  friend point operator*(int lhs, point rhs) {
    return rhs *= lhs;
  }
} pnt[N];
ll det(const point& u, const point& v) {
  return (ll)u.x * v.y - (ll)u.y * v.x;
}
ll dot(const point& u, const point& v) {
  return (ll)u.x * v.x + (ll)u.y * v.y;
}
int quadrant(const point& u) {
  return (u.y < 0) << 1 | ((u.x < 0) ^ (u.y < 0));
}
struct line {
  point p, d;
};
vector<line> half_plane_inter(vector<line> a) {
  a.push_back({{-inf, -inf}, {1, 0}});
  a.push_back({{inf, -inf}, {0, 1}});
  a.push_back({{inf, inf}, {-1, 0}});
  a.push_back({{-inf, inf}, {0, -1}});
  sort(a.begin(), a.end(), [](const line& u, const line& v) {
    int qu = quadrant(u.d), qv = quadrant(v.d);
    if (qu != qv) return qu < qv;
    ll d = det(u.d, v.d);
    return d ? d > 0 : det(v.p - u.p, u.d) > 0;
  });
  a.erase(unique(a.begin(), a.end(), [](const line& u, const line& v) {
    return quadrant(u.d) == quadrant(v.d) && det(u.d, v.d) == 0;
  }), a.end());
  auto above = [](const line& u, const line& v, const line& w) {
    return det(v.d, u.p - v.p) * det(u.d, w.d) >
           det(w.d, u.p - w.p) * det(u.d, v.d);
  };
  auto above_eq = [](const line& u, const line& v, const line& w) {
    return det(v.d, u.p - v.p) * det(u.d, w.d) >=
           det(w.d, u.p - w.p) * det(u.d, v.d);
  };
  int hd = 0, tl = -1;
  vector<line> que(a.size());
  for (auto it : a) {
    while (hd < tl && above(que[tl - 1], que[tl], it)) --tl;
    while (hd < tl && above(it, que[hd], que[hd + 1])) ++hd;
    que[++tl] = it;
  }
  while (hd < tl && above(que[tl - 1], que[tl], que[hd])) --tl;
  if (tl - hd + 1 <= 2) return {};
  if (det(que[hd].d, que[hd + 1].d) <= 0) return {};
  for (auto it : a) if (!above_eq(que[hd], it, que[hd + 1])) return {};
  return {que.begin() + hd, que.begin() + tl + 1};
}
int euclid(int n, int a, int b, int c) {
  // debug("%d %d %d %d", n, a, b, c);
  int s0 = n + 1, s1 = n * (n + 1) / 2;
  int ac = a / c, bc = b / c, m = (a * n + b) / c;
  if (!a) return s0 * bc;
  if (a >= c || b >= c)
    return s1 * ac + s0 * bc + euclid(n, a % c, b % c, c);
  return n * m - euclid(m - 1, c, c - b - 1, a);
}
int floor_sum(int p, int q, int r, int n) {
  if (q < 0) p = -p, q = -q, r = -r;
  if (p < 0) r += n * p, p = -p;
  int ans = 0;
  ans += (n + 1) * (r / q), r %= q;
  if (r < 0) ans -= n + 1, r += q;
  return ans + euclid(n, p, r, q);
}
int floor_sum(int p, int q, int r, int ql, int qr) {
  if (ql > qr) return 0;
  return floor_sum(p, q, r + ql * p, qr - ql);
}
int calc_below(const line& u, int l, int r) {
  if (l > r) return 0;
  return (r - l + 1) * u.p.y + floor_sum(u.d.y, u.d.x, -u.p.x * u.d.y - 1, l, r);
}
int calc_below_eq(const line& u, int l, int r) {
  if (l > r) return 0;
  return (r - l + 1) * u.p.y + floor_sum(u.d.y, u.d.x, -u.p.x * u.d.y, l, r);
}
int calc(const vector<line>& ln) {
  if (ln.empty()) return 0;
  int m = ln.size(), ans = 0;
  for (int i = 0; i < m; ++i) {
    line u = ln[(i + m - 1) % m], v = ln[i], w = ln[(i + 1) % m];
    ll dnu = det(u.d, v.d), upu = u.p.x * dnu + det(v.p - u.p, v.d) * u.d.x;
    ll dnw = det(v.d, w.d), upw = v.p.x * dnw + det(w.p - v.p, w.d) * v.d.x;
    if (v.d.x > 0) {
      ll lft = div_c(upu, dnu);
      ll rht = w.d.x > 0 ? div_c(upw, dnw) - 1 : div_f(upw, dnw);
      ans -= calc_below(v, lft, rht);
    } else if (v.d.x < 0) {
      ll lft = div_c(upw, dnw);
      ll rht = u.d.x < 0 ? div_c(upu, dnu) - 1 : div_f(upu, dnu);
      ans += calc_below_eq(v, lft, rht);
    }
  }
  return ans;
}
bool Med;
int main() {
  // debug("Mem: %.4lfMB.", fabs(&Med - &Mbe) / 1048576);
  cin.tie(0)->sync_with_stdio(0);
  cin >> n;
  for (int i = 0; i < n; ++i) {
    cin >> pnt[i].x >> pnt[i].y;
    chkmax(lmt, pnt[i].x);
    chkmax(lmt, pnt[i].y);
  }
  ll ans = 0;
  reverse(pnt + 1, pnt + n);
  for (int dx = 1; dx <= lmt; ++dx) {
    for (int dy = 0; dx + dy <= lmt; ++dy) {
      vector<point> vec;
      vec.push_back({0, 0});
      vec.push_back({dx, dy});
      vec.push_back({dx - dy, dx + dy});
      vec.push_back({-dy, dx});
      vector<line> ln;
      for (int i = 0; i < n; ++i) {
        int j = (i + 1) % n;
        for (auto it : vec) {
          ln.push_back({pnt[i] - it, pnt[j] - pnt[i]});
        }
      }
      ans += calc(half_plane_inter(ln));
    }
  }
  cout << ans << '\n';
  return 0;
}
/*
g++ -std=c++14 -O2 -o B B.cpp -Wall -Wextra
-Wshadow -fsanitize=address,undefined -g
*/