#include <map>
#include <cmath>
#include <vector>
#include <iostream>
#include <algorithm>
#include <unordered_map>

using namespace std;

#define N 2010
#define eps 1e-8
#define x first
#define y second
#define endl '\n'
#define PDD pair<double, double>

int n;
PDD q[N];
int stk[N], top;
bool st[N];

PDD operator- (PDD a, PDD b) { return {a.x - b.x, a.y - b.y};}
double cross (PDD a, PDD b) { return a.x * b.y - b.x * a.y;}
double area (PDD a, PDD b, PDD c) { return cross(b - a, c - a);}

void andrew() {
    sort(q + 1, q + n + 1);
    
    for (int i = 1; i <= n; ++ i) {
        while(top >= 2 && area(q[stk[top - 1]], q[stk[top]], q[i]) <= 0) {
            if(area(q[stk[top - 1]], q[stk[top]], q[i]) < 0) st[stk[top --]] = false;
            else top --;
        }
        stk[++ top] = i;
        st[i] = true;
    }
    
    st[1] = false;
    for (int i = n; i >= 1; -- i) {
        if(st[i]) continue;
        while(top >= 2 && area(q[stk[top - 1]], q[stk[top]], q[i]) <= 0) {
            if(area(q[stk[top - 1]], q[stk[top]], q[i]) < 0) st[stk[top --]] = false;
            else top --;
        }
        stk[++ top] = i;
        st[i] = true;
    }
}

int dcmp(double a, double b) {
    if(fabs(a - b) < eps) return 0;
    if(a < b) return -1;
    return 1;
}

struct node {
    PDD po;
    int idx;
    
    node(PDD po = {0, 0}, int idx = 0) : po(po), idx(idx) {}
    
    node operator - (const node& A) {
        po = po - A.po;
        return *this;
    }
};

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    
    cin >> n;
    for (int i = 1; i <= n; ++ i) {
        cin >> q[i].x >> q[i].y;
    }
    
    andrew();
    
    vector<PDD> v;
    for (int i = 1; i <= n; ++ i) {
        if(!st[i]) v.push_back(q[i]);
    }

    PDD o;
    auto cmp = [&](node a, node b) {
        a = a - o;
        b = b - o;
        if(dcmp(atan2(a.po.y, a.po.x), atan2(b.po.y, b.po.x)) == 0) return a.po.x < b.po.x;
        return dcmp(atan2(a.po.y, a.po.x), atan2(b.po.y, b.po.x)) < 0;
    };
    
    int ans = 1;
    
    vector<node> p;
    for (int i = 0; i < v.size(); ++ i) {
        o = v[i];
        p.clear();
        for (int j = 1; j <= n; ++ j) {
            if(q[j] == o) continue;
            if(st[j]) p.push_back({q[j], 1});
            else p.push_back({q[j], 0});
        }
        sort(p.begin(), p.end(), cmp);
        for (int j = 0; j < p.size() - 1; ++ j) {
            if(p[j].idx && p[j + 1].idx) ++ ans;
        }
        if(p[p.size() - 1].idx && p[0].idx) ++ ans;
    }
    cout << ans << endl;
    return 0;
}