#include <bits/stdc++.h>

using namespace std;

using i64 = long long;

using f64 = i64;

struct Point {
    f64 x, y;
    Point(f64 x = 0, f64 y = 0) : x(x), y(y) {}
    Point& operator=(const Point& p) {
        x = p.x;
        y = p.y;
        return *this;
    }
};

typedef Point Vector;

Vector operator+(Vector A, Vector B) { return {A.x + B.x, A.y + B.y}; }

Vector operator-(Vector A, Vector B) { return {A.x - B.x, A.y - B.y}; }

Vector operator*(Vector A, f64 p) { return {A.x * p, A.y * p}; }

Vector operator/(Vector A, f64 p) { return {A.x / p, A.y / p}; }

bool operator<(const Point& a, const Point& b) { return a.x < b.x || (a.x == b.x && a.y < b.y); }

f64 Cross(Vector A, Vector B) { return A.x * B.y - A.y * B.x; }

f64 Dot(Vector A, Vector B) { return A.x * B.x + A.y * B.y; }

bool operator==(const Point& a, const Point& b) { return a.x == b.x && a.y == b.y; }

f64 Dist2(const Point& A, const Point& B) {
    return (A.x - B.x) * (A.x - B.x) + (A.y - B.y) * (A.y - B.y);
}

double Dist(const Point& A, const Point& B) { return sqrt(Dist2(A, B)); }

vector<int> ConvexHull(vector<Point>& p) {
    sort(p.begin(), p.end());
    p.erase(unique(p.begin(), p.end()), p.end());
    int n = p.size(), m = 0;
    vector<Point> ch(n + 1);
    vector<int> rt;
    for (int i = 0; i < n; i++) {
        while (m > 1 && Cross(ch[m - 1] - ch[m - 2], p[i] - ch[m - 2]) <= 0) m--;
        ch[m++] = p[i];
        rt.emplace_back(i);
    }
    int k = m;
    for (int i = n - 2; i >= 0; i--) {
        while (m > k && Cross(ch[m - 1] - ch[m - 2], p[i] - ch[m - 2]) <= 0) m--;
        ch[m++] = p[i];
        rt.emplace_back(i);
    }
    if (n > 1) m--;
    rt.resize(m);
    return rt;
}

struct Node {
    Point p;
    int id;
    Node(Point _p, int _id) : p(_p), id(_id) {}
};

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int n;
    cin >> n;
    vector<Point> p(n);
    for (int i = 0; i < n; i += 1) {
        cin >> p[i].x >> p[i].y;
    }
    vector<int> convex = ConvexHull(p);
    vector<bool> vis(n);
    for (int i = 0; i < convex.size(); i += 1) {
        vis[convex[i]] = true;
    }
    i64 ans = 1;
    for (int i = 0; i < n; i += 1) {
        if (vis[i]) continue;
        vector<Node> d;
        for (int j = 0; j < n; j += 1) {
            if (i == j) continue;
            d.emplace_back(p[j], vis[j]);
        }
        sort(d.begin(), d.end(), [&](Node& a, Node& b) {
            if (Cross(a.p - p[i], b.p - p[i]) > 0) return true;
            else return false;
        });
        int m = d.size();
        for (int j = 0; j < m; j += 1) {
            if (d[j].id && d[(j + 1) % m].id) {
                ans += 1;
                // cerr << p[i].x << " " << p
            }
        }
    }
    cout << ans << "\n";

    return 0;
}