#include <iostream>
#include <algorithm>
#include <set>
#include <cmath>
using namespace std;

using ll = long long;
using ull = unsigned long long;
using i128 = __int128_t;
using u128 = __uint128_t;
using ld = long double;
constexpr size_t MAXN = 1e5 + 5;
constexpr ld pi = 3.14159265358979304228043196465883131283866529520193964395724800;

size_t n;

struct u256 {
    u128 h, l;
    u256(u128 h, u128 l): h(h), l(l) {}
    u256(u128 x): h(0), l(x) {}
    friend u256 operator*(u256 x, u256 y)
    {
        return {x.h * y.l + x.l * y.h, x.l * y.l};
    }
    friend bool operator<(u256 x, u256 y)
    {
        return x.h < y.h || (x.h == y.h && x.l < y.l);
    }
    friend bool operator==(u256 x, u256 y)
    {
        return x.h == y.h && x.l == y.l;
    }
    friend bool operator<=(u256 x, u256 y)
    {
        return x < y || x == y;
    }
};

struct Point {
    ll x, y;

    friend Point operator-(Point u, Point v)
    {
        return {u.x - v.x, u.y - v.y};
    }

    friend bool operator==(Point u, Point v)
    {
        return u.x == v.x && u.y == v.y;
    }

    friend bool operator<(Point u, Point v)
    {
        return u.x < v.x || (u.x == v.x && u.y < v.y);
    }
} points[MAXN], convex[MAXN], inner[MAXN];

size_t n_cvx, n_inner;
set<Point> st;

bool cmp1(Point u, Point v)
{
    return u.x < v.x || (u.x == v.x && u.y > v.y);
}

ll cross(Point u, Point v)
{
    return u.x * v.y - u.y * v.x;
}

struct Cmp {
    Point o;
    bool operator()(Point u, Point v)
    {
        return cross(u - o, v - o) > 0;
    }
} cmp2;

size_t stk[MAXN], top;

i128 sqr(ll x)
{
    return (i128) x * x;
}

ll dot(Point u, Point v)
{
    return u.x * v.x + u.y * v.y;
}

ll len2(Point u)
{
    return u.x * u.x + u.y * u.y;
}

int sgn(ll x)
{
    return x > 0 ? 1 : -1;
}

void andrew()
{
    sort(points + 1, points + n + 1, cmp1);
    
    top = 0;
    for (size_t i = 1; i <= n; i++)
    {
        while (top >= 2 && cross(points[stk[top]] - points[stk[top - 1]], 
            points[i] - points[stk[top]]) < 0)
        {
            top--;
        }
        stk[++top] = i;
    }
    for (size_t i = 1; i < top; i++)
    {
        convex[++n_cvx] = points[stk[i]];
        st.insert(points[stk[i]]);
    }
    top = 0;
    for (size_t i = n; i >= 1; i--)
    {
        while (top >= 2 && cross(points[stk[top]] - points[stk[top - 1]], 
            points[i] - points[stk[top]]) < 0)
        {
            top--;
        }
        stk[++top] = i;
    }
    for (size_t i = 1; i < top; i++)
    {
        convex[++n_cvx] = points[stk[i]];
        st.insert(points[stk[i]]);
    }
}

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cin >> n;
    for (size_t i = 1; i <= n; i++)
    {
        cin >> points[i].x >> points[i].y;
    }
    andrew();
    ull ans = 1;
    for (size_t i = 1; i <= n; i++)
    {
        if (st.find(points[i]) == st.end())
        {
            inner[++n_inner] = points[i];
        }
    }
    for (size_t i = 1; i <= n_cvx; i++)
    {
        Point a = convex[i], b = convex[i % n_cvx + 1];
        cmp2.o = a;
        sort(inner + 1, inner + n_inner + 1, cmp2);
        ll cos_up = -1;
        i128 cos_down = 1;
        for (size_t k = 1; k <= n_inner; k++)
        {
            Point p = inner[k];
            ll dot_prod = dot(p - b, a - b);
            ll norm1 = len2(p - b), norm2 = len2(a - b); // 1e12
            i128 norm = (i128) norm1 * norm2; // 1e24
            if (sgn(dot_prod) > sgn(cos_up) ||
                (sgn(dot_prod) == 1 && sgn(cos_up) == 1 &&
                 (u256) sqr(cos_up) * norm <= (u256) sqr(dot_prod) * cos_down) ||
                (sgn(dot_prod) == -1 && sgn(cos_up) == -1 &&
                 (u256) sqr(dot_prod) * cos_down <= (u256) sqr(cos_up) * norm)
            )
            {
                ans++;
                cos_up = dot_prod; // 1e12
                cos_down = norm;
            }
        }
    }
    cout << ans << '\n';
    return 0;
}