#pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
template <class T>
void chkmin(T &x, const T &y) {
  if (x > y) x = y;
}
template <class T>
void chkmax(T &x, const T &y) {
  if (x < y) x = y;
}
using ll = long long;
const int N = 2010;

struct point {
  int x, y;
  point operator-(const point &rhs) const { return {x - rhs.x, y - rhs.y}; }
  bool operator==(const point &rhs) const { return x == rhs.x && y == rhs.y; }
};
ll cross(const point &a, const point &b) {
  return (ll)a.x * b.y - (ll)a.y * b.x;
}
int rowl[N], rowr[N], coll[N], colr[N], mxl[N][N];
std::bitset<N> chk[N];

int main() {
  std::cin.tie(0)->sync_with_stdio(0);
  std::fill(rowl, rowl + N, 1e7);
  std::fill(rowr, rowr + N, -1e7);
  std::fill(coll, coll + N, 1e7);
  std::fill(colr, colr + N, -1e7);
  int n;
  std::cin >> n;
  std::vector<point> a(n);
  for (auto &[x, y] : a) std::cin >> x >> y;
  auto check = [&](point u) {
    for (int i = 0; i < n; i++) {
      auto l = a[i ? i - 1 : n - 1], m = a[i], r = a[(i + 1) % n];
      auto v1 = l - m, v2 = r - m;
      if (cross(v1, v2) == 0) continue;
      if (cross(v1, v2) < 0) std::swap(v1, v2);
      if (cross(v1, u - m) < 0) return false;
      if (cross(u - m, v2) < 0) return false;
    }
    return true;
  };
  for (int i = 0; i < N; i++)
    for (int j = 0; j < N; j++)
      if (check({i, j})) {
        chk[i][j] = 1;
        chkmin(rowl[i], j), chkmax(rowr[i], j);
        chkmin(coll[j], i), chkmax(colr[j], i);
      }
  for (int i = N - 2; i >= 0; i--)
    for (int j = N - 2; j >= 0; j--) {
      mxl[i][j] =
          std::min({mxl[i + 1][j], mxl[i][j + 1], mxl[i + 1][j + 1]}) + 1;
      if (!chk[i][j]) mxl[i][j] = 0;
    }
  std::cerr << clock() / 1e3 << '\n';
  ll ans = 0;
  for (int i = 0; i < N; i++) {
    if (rowl[i] > rowr[i]) continue;
    for (int k = 0; k < N; k++) {
      int l1 = std::max(rowl[i] - k, 1), r1 = rowr[i] - k;
      if (i > colr[k]) continue;
      // for (int j = i + 1; j <= mxl[i][k] + i - 1; j++) {
      //   ans += j - i;
      // }
      int tl = 1, tr = mxl[i][k] - 1;
      if (tr >= tl) ans += (ll)(tl + tr) * (tr - tl + 1) / 2;
      for (int j = mxl[i][k] + i; j < N && k + j - i < N; j++) {
        if (colr[k + j - i] < coll[k + j - i]) continue;
        if (rowr[j] < rowl[j]) continue;
        int t = k + j - i;
        int r = std::min({r1, t - rowl[j], j - coll[k], colr[t] - i, j - i});
        int l = std::max({l1, t - rowr[j], j - colr[k], coll[t] - i});
        if (r >= l) ans += r - l + 1;
      }
    }
  }
  std::cout << ans << '\n';
}