#pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef unsigned long long int ull;

mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
ll myRand(ll B) {
    return (ull)rng() % B;
}
inline double time() {
    return static_cast<long double>(chrono::duration_cast<chrono::nanoseconds>(chrono::steady_clock::now().time_since_epoch()).count()) * 1e-9;
}

// https://onlinejudge.u-aizu.ac.jp/courses/library/4/CGL/all
////////////////////////////////////////////////////////////////////////////////
typedef ll Real;
const Real eps = 0; // 1000 : 10^-8, 10000 : 10^-7
inline int sgn(Real a, Real b = 0) { return (a-b < -eps) ? -1 : (a-b > eps) ? 1 : 0; }
inline Real _sqrt(Real a) { return sqrt(max(a, (Real)0)); }
struct Point {
    Real x, y;
    Point() {}
    Point(Real x, Real y) : x(x), y(y) {}
    Point& operator-=(const Point &p) {
        x -= p.x; y -= p.y;
        return *this;
    }
    Point& operator+=(const Point &p) {
        x += p.x; y += p.y;
        return *this;
    }
    Point& operator*=(Real d) {
        x *= d; y *= d;
        return *this;
    }
    Point& operator/=(Real d) {
        x /= d; y /= d;
        return *this;
    }
    Point operator+ (const Point& p) const {
        Point res(*this); return res += p;
    }
    Point operator- (const Point& p) const {
        Point res(*this); return res -= p;
    }
    Point operator* (Real d) const {
        Point res(*this); return res *= d;
    }
    Point operator/ (Real d) const {
        Point res(*this); return res /= d;
    }
    bool operator< (const Point &p) const {
        return (sgn(x, p.x) < 0 or (sgn(x, p.x) == 0 and sgn(y, p.y) < 0));
    }
    bool operator== (const Point& p) const {
        return (sgn(x - p.x) == 0 and sgn(y - p.y) == 0);
    }
    friend istream &operator>> (istream &is, Point &p) {
        is >> p.x >> p.y; return (is);
    }
    Real norm() { return _sqrt(x*x + y*y); }
    Real norm2() { return (x*x + y*y); }
    Point vec() { return (*this); }
    Point unit() { return (*this)/this->norm(); } // 単位ベクトル
    Point perpendicular() { return {-y, x}; }
    Point normal() { return perpendicular().unit(); } // 法線ベクトル
};

Point vec(Point a, Point b) { return (b - a); }
Real dist(Point a, Point b) { return vec(a, b).norm(); }
Real dot(Point a, Point b) { return a.x*b.x + a.y*b.y; }
Real cross(Point a, Point b) { return a.x*b.y - a.y*b.x; }

// 線分
struct Segment : array<Point,2> {
    Segment() {}
    Segment(Point a, Point b) { at(0) = a, at(1) = b; }
    Point vec() { return (at(1) - at(0)); }
    Real length() { return vec().norm(); }
    friend istream &operator>> (istream &is, Segment &s) {
        is >> s[0] >> s[1]; return (is);
    }
};
// 直線
struct Line : Segment {
    Line() {}
    Line(Point a, Point b) : Segment(a, b) {}
    Line(Segment s) : Line(s[0], s[1]) {}
};

int ccw(Point a, Point b, Point c) {
    b -= a; c -= a;
    if (sgn(cross(b, c)) == 1) return 1; // a,b,c 反時計回り
    if (sgn(cross(b, c)) == -1) return -1; // a,b,c 時計周り
    if (sgn(dot(b, c)) == -1) return 2; // c,a,b 一直線上
    if (sgn(c.norm() - b.norm()) == 1) return -2; // a,b,c 一直線上
    return 0; // a,c,b 一直線上
}

// 多角形ライブラリ
struct Polygon : public vector<Point> {
    Polygon() {}
    Polygon(int n) { this->resize(n); }
    Polygon(vector<Point> init) {
        this->resize(init.size());
        for (int i = 0; i < (int)init.size(); ++i) { (*this)[i] = init[i]; }
    }
    Polygon(initializer_list<Point> init) : Polygon(vector<Point> (init.begin(), init.end())) {}
    void rev() { if(sgn(area()) == -1) reverse(this->begin(), this->end()); }
    // 多角形の符号付き面積(反時計回りが正)
    Real area() {
        int n = this->size(); Real s = 0;
        for (int i = 0; i < n; ++i) {
            s += cross((*this)[i], (*this)[(i+1) % n]);
        }
        return s * 0.5;
    }
    // 多角形の凸性判定(反時計周りを仮定)
    bool is_convex() {
        int n = this->size();
        for (int i = 0; i < n; ++i) {
            if (ccw((*this)[i], (*this)[(i+1) % n], (*this)[(i+2) %n]) == -1) return false;
        }
        return true;
    }
    enum Type { OUT, ON, IN };
};

// 凸包 (線分上の点を含めるかどうか)
Polygon convex_full(vector<Point> ps, bool ONSEG = false) {
    int n = (int)ps.size();
    if (n <= 2) return ps;
    sort(ps.begin(), ps.end());
    int k = 0; // 凸包の頂点数
    Polygon qs(2*n); // 構築中の凸包
    auto check = [&](int _ccw) {
        return ONSEG ? _ccw == -1 : _ccw <= 0;
    };
    for (int i = 0; i < n; qs[k++] = ps[i++]) {
        while (k >= 2 and check(ccw(qs[k-2], qs[k-1], ps[i]))) k--;
    }
    for (int i = n-2, t = k+1; i >= 0; qs[k++] = ps[i--]) {
        while (k >= t and check(ccw(qs[k-2], qs[k-1], ps[i]))) k--;
    }
    qs.resize(k-1);
    return qs;
}

int arg_area(Point p){
    if(p.y < 0) return 2;
    else if(p.x < 0) return 1;
    else return 0;
}
// 整数範囲の偏角ソート　同一点ないと仮定
// 同一偏角の場合は原点に近い方を優先
bool arg_comp(Point a, Point b){
    int ap = arg_area(a), bp = arg_area(b);
    if(ap != bp) return ap < bp;
    auto crs = cross(a, b);
    if(crs == 0) return abs(a.x)+abs(a.y) < abs(b.x)+abs(b.y);
    else return crs > 0;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int n; cin >> n;
    vector<Point> ps(n);
    for (int i = 0; i < n; ++i) {
        cin >> ps[i];
    }
    auto convex = convex_full(ps);
    int m = convex.size();
    vector<bool> cov(n);
    for (int i = 0; i < m; ++i) {
        for (int j = 0; j < n; ++j) {
            if (ps[j] == convex[i]) cov[j] = true;
        }
    }
    int res = 1;
    for (int i = 0; i < m; ++i) {
        if (n == m) break;
        auto p1 = convex[i];
        auto p2 = convex[(i+1)%m];
        int idx = 0;
        vector<pair<Point,int>> pre,bac;
        pre.push_back({convex[(i-1+m)%m]-p1, -1});
        bac.push_back({convex[(i+2)%m]-p2, -1});
        for (int j = 0; j < n; ++j) {
            if (cov[j]) continue;
            pre.push_back({ps[j]-p1, idx});
            bac.push_back({ps[j]-p2, idx});
            idx += 1;
        }
        sort(pre.begin(), pre.end(), [&](auto i, auto j){
            return arg_comp(i.first, j.first);
        });
        sort(bac.begin(), bac.end(), [&](auto i, auto j){
            return arg_comp(i.first, j.first);
        });
//        cout << p1.x << " " << p1.y << " " << p2.x <<  " " << p2.y << endl;
        vector<int> v;
        for (int j = 0; j < pre.size(); ++j) {
            if (pre[j].second == -1) {
                int id = j;
                for (int k = 1; k < pre.size(); ++k) {
                    id -= 1;
                    if (id == -1) id += pre.size();
//                    cout << pre[id].first.x << "," << pre[id].first.y << " ";
                    v.push_back(pre[id].second);
                }
            }
        }
//        cout << endl;
        for (int j = 0; j < bac.size(); ++j) {
            if (bac[j].second == -1) {
                int id = j;
                for (int k = 1; k < bac.size(); ++k) {
                    id -= 1;
                    if (id == -1) id += bac.size();
//                    cout << bac[id].first.x << "," << bac[id].first.y << " ";
                    v.push_back(bac[id].second);
                }
            }
        }
//        cout << endl;
        set<int> ok,ng;
        queue<int> que;
        for (int j = 0; j < v.size(); ++j) {
//            cout << v[j] << " ";
            if (ok.find(v[j]) == ok.end() and ng.find(v[j]) == ng.end()) {
                ok.insert(v[j]);
                que.push(v[j]);
            }
            else {
                if (ng.find(v[j]) != ng.end()) {
                    ng.erase(v[j]);
                }
                else {
                    res += 1;
                    ok.erase(v[j]);
                    while (que.front() != v[j]) {
                        ng.insert(que.front());
                        ok.erase(que.front());
                        que.pop();
                    }
                    que.pop();
                }
            }
        }
//        cout << endl;
    }
    cout << res << endl;
}