#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 1e6 + 7;
const int mod = 998244353;
const ll eps = 1e-7;

struct Point
{
    ll x, y;
    Point() {}
    Point(ll ax, ll ay)
    {
        x = ax, y = ay;
    }
    ll id(){
        return x * 2000000ll + y;
    }
    Point operator-(const Point &b) const
    {
        return Point(x - b.x, y - b.y);
    }
    bool operator<(const Point &b) const
    {
        if (x == b.x)
            return y < b.y;
        return x < b.x;
    }
    bool operator==(const Point &b) const
    {
        return ((x == b.x)) && ((y == b.y));
    }
};
ll cross(Point a, Point b)
{
    return a.x * b.y - a.y * b.x;
}
int lt(double x, double y)
{
    if (x > y)
        return 0;
    return 1;
}
Point O = {0, 0};
double theta(auto p) { return atan2(p.y, p.x); } // 求极角
void psort(vector<Point> &ps, Point c = O)       // 极角排序
{
    sort(ps.begin(), ps.end(), [&](auto p1, auto p2)
         { return lt(theta(p1 - c), theta(p2 - c)); });
}
std::vector<Point> getHull(std::vector<Point> p)
{
    std::vector<Point> h, l;
    std::sort(p.begin(), p.end(), [&](auto a, auto b)
              {
        if (a.x != b.x) {
            return a.x < b.x;
        } else {
            return a.y < b.y;
        } });
    p.erase(std::unique(p.begin(), p.end()), p.end());
    if (p.size() <= 1)
    {
        return p;
    }

    for (auto a : p)
    {
        while (h.size() > 1 && lt(cross(a - h.back(), a - h[h.size() - 2]), 0))
        {
            h.pop_back();
        }
        while (l.size() > 1 && lt(0, cross(a - l.back(), a - l[l.size() - 2])))
        {
            l.pop_back();
        }
        l.push_back(a);
        h.push_back(a);
    }

    l.pop_back();
    std::reverse(h.begin(), h.end());
    h.pop_back();
    l.insert(l.end(), h.begin(), h.end());
    return l;
}
void solve()
{
    int n;
    cin >> n;
    vector<Point> p;
    for (int i = 0; i < n; i++)
    {
        ll x, y;
        cin >> x >> y;
        p.push_back({x, y});
    }
    auto h = getHull(p);
    int ans = 1;
    map<Point, int> pm;
    for (auto x : h)
    {
        pm[x] = 1;
    }
    map<pair<ll, ll>, int> mp;
    for (int j = 1; j < h.size(); j++)
    {
        mp[{h[j - 1].id(), h[j].id()}] = 1;
        mp[{h[j].id(), h[j - 1].id()}] = 1;
    }
    mp[{h.back().id(), h[0].id()}] = mp[{h[0].id(), h.back().id()}] = 1;

    for (int i = 0; i < n; i++)
    {
        if (pm[p[i]])
            continue;
        vector<Point> v;
        for (int j = 0; j < n; j++)
        {
            if (i == j)
                continue;
            v.push_back(p[j]);
        }
        psort(v, p[i]);

        for (int j = 1; j < v.size(); j++)
        {

            if (mp[{v[j].id(), v[j - 1].id()}])
            {
                ans++;
            }
        }
        if (mp[{v.back().id(), v[0].id()}])
            ans++;
    }
    cout << ans << '\n';
}
int main()
{
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int _ = 1;
    // cin >> _;
    while (_--)
        solve();
    return 0;
}