// clang-format off
#ifdef _LOCAL
    #include <pch.hpp>
#else
    #include <bits/stdc++.h>
    #define cerr if (false) cerr
    #define debug_bar
    #define debug(...)
    #define debug2(vv)
    #define debug3(vvv)
#endif

using namespace std;
using ll = long long;
using ld = long double;
using str = string;
using P = pair<ll,ll>;
using VP = vector<P>;
using VVP = vector<VP>;
using VC = vector<char>;
using VS = vector<string>;
using VVS = vector<VS>;
using VI = vector<int>;
using VVI = vector<VI>;
using VVVI = vector<VVI>;
using VLL = vector<ll>;
using VVLL = vector<VLL>;
using VVVLL = vector<VVLL>;
using VB = vector<bool>;
using VVB = vector<VB>;
using VVVB = vector<VVB>;
using VD = vector<double>;
using VVD = vector<VD>;
using VVVD = vector<VVD>;
#define FOR(i,l,r) for (ll i = (l); i < (r); ++i)
#define RFOR(i,l,r) for (ll i = (r)-1; (l) <= i; --i)
#define REP(i,n) FOR(i,0,n)
#define RREP(i,n) RFOR(i,0,n)
#define FORE(e,c) for (auto&& e : c)
#define ALL(c) (c).begin(), (c).end()
#define SORT(c) sort(ALL(c))
#define RSORT(c) sort((c).rbegin(), (c).rend())
#define MIN(c) *min_element(ALL(c))
#define MAX(c) *max_element(ALL(c))
#define COUNT(c,v) count(ALL(c),(v))
#define len(c) ((ll)(c).size())
#define BIT(b,i) (((b)>>(i)) & 1)
#define PCNT(b) ((ll)__builtin_popcountll(b))
#define LB(c,v) distance((c).begin(), lower_bound(ALL(c), (v)))
#define UB(c,v) distance((c).begin(), upper_bound(ALL(c), (v)))
#define UQ(c) do { SORT(c); (c).erase(unique(ALL(c)), (c).end()); (c).shrink_to_fit(); } while (0)
#define END(...) do { print(__VA_ARGS__); exit(0); } while (0)
constexpr ld EPS = 1e-10;
constexpr ld PI  = acosl(-1.0);
constexpr int inf = (1 << 30) - (1 << 15);   // 1,073,709,056
constexpr ll INF = (1LL << 62) - (1LL << 31);  // 4,611,686,016,279,904,256
template<class... T> void input(T&... a) { (cin >> ... >> a); }
void print() { cout << '\n'; }
template<class T> void print(const T& a) { cout << a << '\n'; }
template<class P1, class P2> void print(const pair<P1, P2>& a) { cout << a.first << " " << a.second << '\n'; }
template<class T, class... Ts> void print(const T& a, const Ts&... b) { cout << a; (cout << ... << (cout << ' ', b)); cout << '\n'; }
template<class T> void cout_line(const vector<T>& ans, int l, int r) { for (int i = l; i < r; i++) { if (i != l) { cout << ' '; } cout << ans[i]; } cout << '\n'; }
template<class T> void print(const vector<T>& a) { cout_line(a, 0, a.size()); }
template<class S, class T> bool chmin(S& a, const T b) { if (b < a) { a = b; return 1; } return 0; }
template<class S, class T> bool chmax(S& a, const T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> T SUM(const vector<T>& A) { return accumulate(ALL(A), T(0)); }
template<class T> vector<T> cumsum(const vector<T>& A, bool offset = false) { int N = A.size(); vector<T> S(N+1, 0); for (int i = 0; i < N; i++) { S[i+1] = S[i] + A[i]; } if (not offset) { S.erase(S.begin()); } return S; }
template<class T> string to_binary(T x, int B = 0) { string s; while (x) { s += ('0' + (x & 1)); x >>= 1; } while ((int)s.size() < B) { s += '0'; } reverse(s.begin(), s.end()); return s; }
template<class F> ll binary_search(const F& is_ok, ll ok, ll ng) { while (abs(ok - ng) > 1) { ll m = (ok + ng) / 2; (is_ok(m) ? ok : ng) = m; } return ok; }
template<class F> double binary_search_real(const F& is_ok, double ok, double ng, int iter = 90) { for (int i = 0; i < iter; i++) { double m = (ok + ng) / 2; (is_ok(m) ? ok : ng) = m; } return ok; }
template<class T> using PQ_max = priority_queue<T>;
template<class T> using PQ_min = priority_queue<T, vector<T>, greater<T>>;
template<class T> T pick(stack<T>& s) { assert(not s.empty()); T x = s.top(); s.pop(); return x; }
template<class T> T pick(queue<T>& q) { assert(not q.empty()); T x = q.front(); q.pop(); return x; }
template<class T> T pick_front(deque<T>& dq) { assert(not dq.empty()); T x = dq.front(); dq.pop_front(); return x; }
template<class T> T pick_back(deque<T>& dq) { assert(not dq.empty()); T x = dq.back(); dq.pop_back(); return x; }
template<class T> T pick(PQ_min<T>& pq) { assert(not pq.empty()); T x = pq.top(); pq.pop(); return x; }
template<class T> T pick(PQ_max<T>& pq) { assert(not pq.empty()); T x = pq.top(); pq.pop(); return x; }
template<class T> T pick(vector<T>& v) { assert(not v.empty()); T x = v.back(); v.pop_back(); return x; }
int to_int(const char c) { if (islower(c)) { return (c - 'a'); } if (isupper(c)) { return (c - 'A'); } if (isdigit(c)) { return (c - '0'); } assert(false); }
char to_a(const int i) { assert(0 <= i && i < 26); return ('a' + i); }
char to_A(const int i) { assert(0 <= i && i < 26); return ('A' + i); }
char to_d(const int i) { assert(0 <= i && i <= 9); return ('0' + i); }
ll min(int a, ll b) { return min((ll)a, b); }
ll min(ll a, int b) { return min(a, (ll)b); }
ll max(int a, ll b) { return max((ll)a, b); }
ll max(ll a, int b) { return max(a, (ll)b); }
ll mod(ll x, ll m) { assert(m > 0); return (x % m + m) % m; }
ll ceil(ll a, ll b) { if (b < 0) { return ceil(-a, -b); } assert(b > 0); return (a < 0 ? a / b : (a + b - 1) / b); }
ll floor(ll a, ll b) { if (b < 0) { return floor(-a, -b); } assert(b > 0); return (a > 0 ? a / b : (a - b + 1) / b); }
ll powint(ll x, ll n) { assert(n >= 0); if (n == 0) { return 1; }; ll res = powint(x, n>>1); res *= res; if (n & 1) { res *= x; } return res; }
pair<ll,ll> divmod(ll a, ll b) { assert(b != 0); ll q = floor(a, b); return make_pair(q, a - q * b); }
ll bitlen(ll b) { if (b <= 0) { return 0; } return (64LL - __builtin_clzll(b)); }
ll digitlen(ll n) { assert(n >= 0); if (n == 0) { return 1; } ll sum = 0; while (n > 0) { sum++; n /= 10; } return sum; }
ll msb(ll b) { return (b <= 0 ? -1 : (63 - __builtin_clzll(b))); }
ll lsb(ll b) { return (b <= 0 ? -1 : __builtin_ctzll(b)); }
// --------------------------------------------------------


/** NOTE: 幾何ライブラリの整数版（使えるものだけ存在） **/

// References:
//   『プログラミングコンテスト攻略のためのアルゴリズムとデータ構造』
//   <https://github.com/atcoder/live_library/blob/master/geom/vector.cpp>
//   <https://ei1333.github.io/luzhiled/snippets/geometry/template.html>
//   <https://github.com/E869120/kyopro_educational_90/blob/main/sol/041-03.cpp>


// 点 (ベクトル)
struct Point {
    ll x, y;
    Point(ll x = 0, ll y = 0): x(x), y(y) {}

    Point& operator+=(const Point& v) noexcept { x += v.x; y += v.y; return *this; }
    Point& operator-=(const Point& v) noexcept { x -= v.x; y -= v.y; return *this; }
    // Point& operator*=(ll k) noexcept { x *= k; y *= k; return *this; }
    // Point& operator/=(ll k) noexcept { x /= k; y /= k; return *this; }

    Point operator+(const Point& v) const noexcept { return Point(*this) += v; }
    Point operator-(const Point& v) const noexcept { return Point(*this) -= v; }
    // Point operator*(ll k) const noexcept { return Point(*this) *= k; }
    // Point operator/(ll k) const noexcept { return Point(*this) /= k; }

    ll norm() const noexcept { return x*x + y*y; }  // ベクトルの大きさ
    // ll abs() const noexcept { return sqrt(norm()); }  // 原点からの距離，ベクトルの長さ

    // pair<x, y> の要領で大小比較（x昇順 --> y昇順）
    bool operator < (const Point& p) const noexcept {
        return x != p.x ? x < p.x : y < p.y;
    }

    bool operator == (const Point& p) const noexcept {
        return (x == p.x) && (y == p.y);
    }
};

// 直線
struct Line {
    Point p1, p2;
    Line(Point p1 = Point(), Point p2 = Point()): p1(p1), p2(p2) {}
};

// 線分
struct Segment {
    Point p1, p2;
    Segment(Point p1 = Point(), Point p2 = Point()): p1(p1), p2(p2) {}
};

// 円
struct Circle {
    Point c;  // 中心
    ll r;  // 半径
    Circle(Point c = Point(), ll r = 0): c(c), r(r) {}
};

// 三角形
struct Triangle {
    Point p1, p2, p3;
    Triangle(Point p1 = Point(), Point p2 = Point(), Point p3 = Point()) : p1(p1), p2(p2), p3(p3) {}
};

using Points = vector<Point>;
using Polygon = vector<Point>;  // 多角形
using Segments = vector<Segment>;
using Lines = vector<Line>;
using Circles = vector<Circle>;
using Triangles = vector<Triangle>;

ll norm(const Point& a) { return a.x*a.x + a.y*a.y; }  // ベクトルの大きさ
// ll abs(const Point& a) { return sqrt(norm(a)); }  // 原点からの距離，ベクトルの長さ
ll dot(const Point& a, const Point& b) { return a.x*b.x + a.y*b.y; }  // 内積
ll cross(const Point& a, const Point& b) { return a.x*b.y - a.y*b.x; }  // 外積

// 直交判定 (直線)
bool is_orthogonal(const Line& a, const Line& b) {
    return (dot(a.p1 - a.p2, b.p1 - b.p2) == 0);
}
// 直交判定 (線分)
// ※ 線分の交差判定を先に行う必要あり --> is_intersected()
bool is_orthogonal(const Segment& a, const Segment& b) {
    return (dot(a.p1 - a.p2, b.p1 - b.p2) == 0);
}

// 平行判定 (直線)
bool is_parallel(const Line& a, const Line& b) {
    return (cross(a.p1 - a.p2, b.p1 - b.p2) == 0);
}
// 平行判定 (線分)
bool is_parallel(const Segment& a, const Segment& b) {
    return (cross(a.p1 - a.p2, b.p1 - b.p2) == 0);
}

constexpr int COUNTER_CLOCKWISE = 1;  // 反時計回り (左回り)
constexpr int CLOCKWISE = -1;         // 時計回り   (右回り)
constexpr int ONLINE_BACK = 2;        // 線分後方
constexpr int ONLINE_FRONT = -2;      // 線分前方
constexpr int ON_SEGMENT = 0;         // 線分上

// 3点 p0,p1,p2 の位置関係を線分 p1 - p0 を基準にして求める
int ccw(const Point& p0, const Point& p1, const Point& p2) {
    Point a = p1 - p0;
    Point b = p2 - p0;
    if (cross(a, b) > 0) return COUNTER_CLOCKWISE;  // p0 -> p1, 反時計回りの方向に p2
    if (cross(a, b) < 0) return CLOCKWISE;          // p0 -> p1,   時計回りの方向に p2
    if (dot(a, b) < 0) return ONLINE_BACK;          // p2 -> p0 -> p1 の順で直線上に p2
    if (a.norm() < b.norm()) return ONLINE_FRONT;   // p0 -> p1 -> p2 の順で直線上に p2
    return ON_SEGMENT;                              // p0 -> p2 -> p1 の順で線分上に p2
}

// 線分の交差判定
// 端点だけ重なる場合や平行に重なる場合も交差しているとみなす
bool is_intersected(const Point& p1, const Point& p2, const Point& p3, const Point& p4) {
    return (ccw(p1,p2,p3) * ccw(p1,p2,p4) <= 0) && (ccw(p3,p4,p1) * ccw(p3,p4,p2) <= 0);
}
// 線分の交差判定
// 端点だけ重なる場合や平行に重なる場合も交差しているとみなす
bool is_intersected(const Segment& s1, const Segment& s2) {
    return is_intersected(s1.p1, s1.p2, s2.p1, s2.p2);
}
// 直線と線分の交差判定
// 端点だけ重なる場合や平行に重なる場合も交差しているとみなす
bool is_intersected(const Line& l, const Segment& s) {
    return (ccw(l.p1, l.p2, s.p1) * ccw(l.p1, l.p2, s.p2) <= 0);
}
// 線分上に点が存在するか判定
bool on_segment(const Segment& s, const Point& p) {
    return ccw(s.p1, s.p2, p) == ON_SEGMENT;
}

// 円周上に点が存在するか判定
bool on_circle(const Circle& c, const Point& p) {
    auto dx = c.c.x - p.x;
    auto dy = c.c.y - p.y;
    return dx * dx + dy * dy == c.r * c.r;
}

// 円内部に点が存在するか判定
// 円周上に点が存在する場合は false を返す
bool in_circle(const Circle& c, const Point& p) {
    auto dx = c.c.x - p.x;
    auto dy = c.c.y - p.y;
    return dx * dx + dy * dy < c.r * c.r;
}

// 円における点の内包判定
// 0: 外側, 1: 円周上, 2: 内側
int point_containment(const Circle& c, const Point& p) {
    if (in_circle(c, p)) { return 2; }
    if (on_circle(c, p)) { return 1; }
    return 0;
}

// 円の交差判定
// 2つの円の共通接線の数を計算する
//   4本: 離れている
//   3本: 外接
//   2本: 2点交差
//   1本: 内接
//   0本: 内包
int circle_intersection(const Circle& c1, const Circle& c2) {
    auto dx = c1.c.x - c2.c.x;
    auto dy = c1.c.y - c2.c.y;
    ll d2 = dx * dx + dy * dy;
    ll r2 = (c1.r - c2.r) * (c1.r - c2.r);
    ll R2 = (c1.r + c2.r) * (c1.r + c2.r);
    if (R2 < d2) { return 4; }
    if (R2 == d2) { return 3; }
    if (r2 < d2) { return 2; }
    if (r2 == d2) { return 1; }
    return 0;
}

// 円の交差判定
// 外接・2点交差・内接の場合に交差していると判定する
bool is_intersected(const Circle& c1, const Circle& c2) {
    int n = circle_intersection(c1, c2);
    return (n == 3 || n == 2 || n == 1);
}

// 三角形の (2 * 符号付き面積) を求める
//   - 符号： 頂点列が反時計回りの場合は正、時計回りの場合は負
ll area_of_triangle(const Point& A, const Point& B, const Point& C) {
    ll area = cross(B - A, C - A);
    return area;
    // return area / 2;
}

// 三角形の (2 * 符号付き面積) を求める
//   - 符号： 頂点列が反時計回りの場合は正、時計回りの場合は負
ll area_of_triangle(const Triangle& t) {
    return area_of_triangle(t.p1, t.p2, t.p3);
}

// 3 点が同一直線上にあるか判定する
bool are_on_same_line(const Point& p1, const Point& p2, const Point& p3) {
    return abs(ccw(p1, p2, p3)) != 1;
}

// 多角形の (2 * 符号付き面積) を求める
//   - 3 ≦ 頂点数
//   - 符号： 頂点列が反時計回りの場合は正、時計回りの場合は負
//   - 多角形が自己交差していないことを想定
// <https://ja.wikipedia.org/wiki/%E5%A4%9A%E8%A7%92%E5%BD%A2>
ll area_of_polygon(const Polygon& P) {
    int N = P.size();
    assert(3 <= N);
    ll area = 0;
    for (int i = 0; i < N; i++) {
        area += cross(P[i], P[(i+1) % N]);  // N番目の次は1番目
    }
    return area;
    // return area / 2;
}

// 凸性判定 (多角形が凸多角形であるか判定)
//   - 3 ≦ 頂点数
//   - 頂点列が反時計回りであることを想定
//   - 多角形が自己交差していないことを想定
bool is_convex(const Polygon& P) {
    int N = P.size();
    assert(3 <= N);
    for (int i = 0; i < N; i++) {
        if (ccw(P[(i-1+N) % N], P[i], P[(i+1+N) % N]) == CLOCKWISE) return false;
    }
    return true;
}

// 多角形における点の内包判定
//   - 0: 外側, 1: 線分上, 2: 内側
int point_containment(const Polygon& g, const Point& p) {
    int N = g.size();
    bool x = false;
    for (int i = 0; i < N; i++) {
        Point a = g[i] - p;
        Point b = g[(i+1) % N] - p;  // N番目の次は1番目
        if (cross(a, b) == 0 && dot(a, b) <= 0) return 1;  // 線分上
        if (a.y > b.y) swap(a, b);
        if (a.y <= 0 && 0 < b.y && cross(a, b) > 0) x = !x;  // 半直線との交差回数の偶奇
    }
    return (x ? 2 : 0);
}

// 凸包を求める (Andrew's Monotone Chain)
//   - O(N log N)
//   - 下記が満たされていることを想定
//     - 3 ≦ 頂点数
//     - 全点が一つの直線上に存在しない
//       are_on_same_line(P[0],P[1],P[2..N-1]) を確認すれば判定可能
//   - on_edge: 凸包の辺上の点を含めるか
//   - 凸包の頂点の順序は最も左の頂点から反時計回り (左回り)
Polygon convex_hull(Polygon P, bool on_edge = true) {
    int N = P.size();
    assert(3 <= N);
    sort(P.begin(), P.end());  // x昇順 --> y昇順
    Polygon ch(2*N,{-1,-1});
    int k = 0;
    if (on_edge) {
        // 上包 (upper hull)
        for (int i = 0; i < N; ch[k++] = P[i++]) {
            while (k >= 2 && ccw(ch[k-2], ch[k-1], P[i]) == COUNTER_CLOCKWISE) k--;
        }
        // 下包 (lower hull)
        const int t = k + 1;
        for (int i = N-2; 0 <= i; ch[k++] = P[i--]) {
            while (k >= t && ccw(ch[k-2], ch[k-1], P[i]) == COUNTER_CLOCKWISE) k--;
        }
    } else {
        // 上包 (upper hull)
        for (int i = 0; i < N; ch[k++] = P[i++]) {
            while (k >= 2 && ccw(ch[k-2], ch[k-1], P[i]) != CLOCKWISE) k--;
        }
        // 下包 (lower hull)
        const int t = k + 1;
        for (int i = N-2; 0 <= i; ch[k++] = P[i--]) {
            while (k >= t && ccw(ch[k-2], ch[k-1], P[i]) != CLOCKWISE) k--;
        }
    }
    ch.resize(k-1);
    /** TODO: 最初から反時計回りで計算 **/
    reverse(ch.begin() + 1, ch.end());  // 反時計回りに変換
    return ch;
}

// 最近点対間距離 (の 2 乗) を求める
//   - O(N log N)
ll closest_pair(Points P) {
    int N = P.size();
    assert(2 <= N);
    sort(P.begin(), P.end());
    auto compare_y = [](const Point& a, const Point& b) -> bool { return a.y < b.y; };
    constexpr ll INF = numeric_limits<ll>::max();
    Points B(N);  // x座標を左右に分ける直線付近の点集合を保管用に使い回す配列
    auto rec = [&](auto&& self, int l, int r) -> ll {
        if (r - l <= 1) { return INF; }
        int m = (l + r) / 2;  // x座標を左右に分ける直線のインデックス
        ll x_m = P[m].x;    // x座標を左右に分ける直線のx座標
        ll d = min(self(self, l, m), self(self, m, r));  // 最近点対間距離
        inplace_merge(P.begin() + l, P.begin() + m, P.begin() + r, compare_y);
        int k = 0;
        for (int i = l; i < r; i++) {
            if ((P[i].x - x_m) * (P[i].x - x_m) >= d) { continue; }
            for (int j = k - 1; 0 <= j; j--) {
                ll dx = P[i].x - B[j].x;
                ll dy = P[i].y - B[j].y;
                if (dy*dy >= d) { break; }
                d = min(d, dx*dx + dy*dy);
            }
            B[k++] = P[i];
        }
        return d;
    };
    return rec(rec, 0, N);
}

// 多角形の頂点列が反時計回りか判定する
//   - 符号付き面積の正負で判定する
bool is_counter_clockwise(const Polygon& P) {
    return area_of_polygon(P) > 0;
}

// 三角形の頂点列が反時計回りか判定する
//   - 符号付き面積の正負で判定する
bool is_counter_clockwise(const Triangle& t) {
    return area_of_triangle(t) > 0;
}

// 三角形における点の内包判定
//   - 0: 外側, 1: 線分上, 2: 内側
int point_containment(const Triangle& t, const Point& p) {
    int c12 = ccw(t.p1, t.p2, p);
    int c23 = ccw(t.p2, t.p3, p);
    int c31 = ccw(t.p3, t.p1, p);
    if (c12 ==  0 || c23 ==  0 || c31 ==  0) { return 1; }  // 辺上
    if (c12 == +1 && c23 == +1 && c31 == +1) { return 2; }  // 時計回り
    if (c12 == -1 && c23 == -1 && c31 == -1) { return 2; }  // 反時計回り
    return 0;
}

// 多角形 P において三角形 (P[l],P[m],P[r]) が耳であるか判定する
bool is_ear(const Polygon& P, int l, int m, int r) {
    Triangle t(P[l], P[m], P[r]);

    // 明らかに ear でないケースを除外（この 3 点が mouth or 一直線）
    if (ccw(t.p1, t.p2, t.p3) <= 0) { return false; }

    int N = P.size();
    for (int i = 0; i < N; i++) {
        if (i == l || i == m || i == r) { continue; }
        if (point_containment(t, P[i])) { continue; }
    }
    return true;
}

// 単純多角形を三角形分割する（耳分解）
//   - 3 ≦ 頂点数
//   - 頂点列が反時計回りであることを想定
//   - O(N^2) : ear clipping method によるナイーブな実装
//   - Reference: https://web.archive.org/web/20200222054711/http://www.prefiell.com/algorithm/geometry/triangulate.html
Triangles triangulation_of_polygon(const Polygon& P) {
    int N = P.size();
    assert(2 <= N);

    vector<int> L(N), R(N);  // 左隣・右隣
    for (int i = 0; i < N; i++) {
        L[i] = (i - 1 + N) % N;
        R[i] = (i + 1 + N) % N;
    }

    Triangles ts;
    int m = 0;  // いま見ている３点の真ん中
    while ((int)ts.size() < N-2) {
        m = R[m];
        while (is_ear(P, L[m], m, R[m])) {
            ts.emplace_back(P[L[m]], P[m], P[R[m]]);
            // 真ん中の m を闇に葬る
            R[L[m]] = R[m];
            L[R[m]] = L[m];
        }
    }
    return ts;
}

// 線分上の格子点の個数を求める（端点を除く）
//   - O(log ((x2 - x1) + (y2 - y1)))
ll lattice_point_of_segment(const Point& p1, const Point& p2) {
    return gcd(p2.x - p1.x, p2.y - p1.y) - 1;
}

// 線分上の格子点の個数を求める（端点を除く）
//   - O(log ((x2 - x1) + (y2 - y1)))
ll lattice_point_of_segment(const Segment& s) {
    return lattice_point_of_segment(s.p1, s.p2);
}

// 格子点のみを頂点に持つ多角形の周上・内部の格子点の数をそれぞれ求める（ピックの定理）
//   - 3 ≦ 頂点数
//   - S = B/2 + I - 1
pair<ll,ll> lattice_points_of_polygon(const Polygon& P) {
    int N = P.size();
    ll S2 = abs(area_of_polygon(P));
    ll B = N;
    for (int i = 0; i < N; i++) {
        B += lattice_point_of_segment(P[i], P[(i+1) % N]);
    }
    ll I = (S2 - B) / 2 + 1;
    return make_pair(B, I);
}

// clang-format on
int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cout << fixed << setprecision(15);

    ll N;
    input(N);
    VLL X(N), Y(N);
    REP (i, N) { input(X[i], Y[i]); }

    Points P(N);
    REP (i, N) {
        P[i].x = X[i];
        P[i].y = Y[i];
    }

    ll ans = 0;
    REP (i, N) {
        FOR (j, i + 1, N) {
            ll L = -1, R = -1;
            REP (k, N) {
                if (k == i || k == j) { continue; }
                auto res = ccw(P[i], P[j], P[k]);
                auto T = abs(area_of_triangle(P[i], P[j], P[k]));
                if (res == -1) {
                    chmax(L, T);
                } else if (res == 1) {
                    chmax(R, T);
                }
            }
            if (0 <= L && 0 <= R) {
                chmax(ans, L + R);
            }
        }
    }
    print(ans);

    return 0;
}