#include <bits/stdc++.h>

using namespace std;

using ll = long long;
using ld = long double;

#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define rep(i, n) for (int i = 0; i < (n); i += 1)
#define len(a) ((int)(a).size())

mt19937 rnd(234);
const ll inf = 1e18;

struct vec {
    ll x, y;

    ll len2() const {
        return x * x + y * y;
    }
};

vec operator+(const vec &a, const vec &b) {
    return vec{a.x + b.x, a.y + b.y};
}

vec operator-(const vec &a, const vec &b) {
    return vec{a.x - b.x, a.y - b.y};
}

ll operator*(const vec &a, const vec &b) {
    return a.x * b.x + a.y * b.y;
}

ll operator%(const vec &a, const vec &b) {
    return a.x * b.y - a.y * b.x;
}

int32_t main() {
    if (1) {
        ios::sync_with_stdio(0);
        cin.tie(0);
        cout.tie(0);
    }
    int n;
    cin >> n;
    vector<vec> a(n);
    rep(i, n) {
        cin >> a[i].x >> a[i].y;
    }
    if (n == 1) {
        cout << 2 << "\n";
        return 0;
    }
    int opt = 0;
    rep(i, n) {
        if (make_pair(a[i].x, a[i].y) < make_pair(a[opt].x, a[opt].y)) {
            opt = i;
        }
    }
    swap(a[opt], a.back());
    rep(i, n) {
        a[i] = a[i] - a.back();
    }
    vec bebra = a[0];
    rep(i, n - 1) {
        if (bebra % a[i] > 0) {
            bebra = a[i];
        }
    }
    sort(a.begin(), a.begin() + n - 1, [&](const vec &fst, const vec &snd) {
        ll val = fst % snd;
        if (val != 0) {
            return val > 0;
        }
        if (fst % bebra == 0) {
            return fst.len2() > snd.len2();
        }
        return fst.len2() < snd.len2();
    });
    map<array<int, 6>, ll> dp;
    dp[{n - 1, n - 1, -1, -1, -1, -1}] = 1;
    rep(i, n - 1) {
        map<array<int, 6>, ll> new_dp;
        for (auto &[arr, cnt] : dp) {
            bool ok1 = (a[i] - a[arr[1]]) % (a[arr[1]] - a[arr[0]]) <= 0;
            if (ok1) {
                array<int, 6> new_arr = arr;
                new_arr[0] = arr[1];
                new_arr[1] = i;
                new_dp[new_arr] += cnt;
            }
            if (arr[2] == -1) {
                array<int, 6> new_arr = arr;
                new_arr[2] = new_arr[3] = new_arr[4] = new_arr[5] = i;
                new_dp[new_arr] += cnt;
                continue;
            }
            if (arr[2] != -2) {
                bool ok2 = (a[i] - a[arr[3]]) % (a[arr[3]] - a[arr[2]]) <= 0;
                if (ok2) {
                    array<int, 6> new_arr = arr;
                    new_arr[2] = arr[3];
                    new_arr[3] = i;
                    new_dp[new_arr] += cnt;
                }
                bool ok3 = (a[i] - a[arr[5]]) % (a[arr[5]] - a[arr[4]]) >= 0;
                if (ok3) {
                    array<int, 6> new_arr = arr;
                    new_arr[4] = arr[5];
                    new_arr[5] = i;
                    new_dp[new_arr] += cnt;
                }
                if (ok2 & ok3) {
                    array<int, 6> new_arr = arr;
                    new_arr[2] = new_arr[3] = new_arr[4] = new_arr[5] = -2;
                    new_dp[new_arr] += cnt;
                }
            }
        }
        dp.swap(new_dp);
    }
    ll result = 0;
    for (auto [arr, cnt] : dp) {
        bool ok = (a[n - 1] - a[arr[1]]) % (a[arr[1]] - a[arr[0]]) <= 0;
        if (ok and (arr[2] == -2 or arr[2] == -1 or arr[3] == arr[5])) {
            result += cnt;
        }
    }
    result *= 2;
    cout << result << "\n";
    return 0;
}