#include <iostream>
#include <vector>
#include <set>
#include <map>
#include <utility>
#include <algorithm>
using namespace std;
typedef long long ll;
#define vl vector<ll>
#define pll pair<ll,ll>

ll my_gcd(ll a, ll b){
    ll ret = 0;
    if (a < b){
        swap(a, b);
    }
    if (b == 0){
        ret = a;
    }
    else{
        ret = my_gcd(b, a % b);
    }
    return ret;
}

int main(){
    ll N;
    cin >> N;
    vector<ll> X(N);
    vector<ll> Y(N);
    for (ll i = 0; i < N; i++){
        cin >> X[i] >> Y[i];
    }
    //map<ll, ll> mp1; //x軸に平行
    //map<ll, ll> mp2; //y軸に平行
    map<pair<pll, pll>, ll> mp3; //それ以外
    vector<vector<pair<pll, pll>>> grad_vec(N, vector<pair<pll, pll>>(N));
    for (ll i = 0; i < N; i++){
        for (ll j = i + 1; j < N; j++){
            if (X[i] == X[j]){
                pair<ll,ll> g1 = pair<ll,ll>(X[i], 0);
                pair<ll,ll> g2 = pair<ll,ll>(-1, -1);
                mp3[pair<pll, pll>(g1, g2)]++;
                grad_vec[i][j] = pair<pll,pll>(g1, g2);
            }
            else if (Y[i] == Y[j]){
                pair<ll,ll> g1 = pair<ll,ll>(0, Y[i]);
                pair<ll,ll> g2 = pair<ll,ll>(-1, -1);
                mp3[pair<pll, pll>(g1, g2)]++;
                grad_vec[i][j] = pair<pll, pll>(g1, g2);
            }
            else{
                pll p1;
                pll p2;
                ll g1 = my_gcd(abs(Y[j] - Y[i]), abs(X[j] - X[i]));
                p1.first = (Y[j] - Y[i]) / g1;
                p1.second = (X[j] - X[i]) / g1;
                if (p1.second < 0){
                    p1.first *= -1;
                    p1.second *= -1;
                }
                ll v1 = X[j] * Y[i] - X[i] * Y[j];
                ll v2 = X[j] - X[i];
                ll g2 = 1;
                if (v1 != 0){
                    g2 = my_gcd(abs(v1), abs(v2));
                }
                else{
                    g2 = v2;
                }
                p2.first = v1 / g2;
                p2.second = v2 / g2;
                if (p2.second < 0){
                    p2.first *= -1;
                    p2.second *= -1;
                }
                mp3[pair<pll, pll>(p1, p2)]++;
                grad_vec[i][j] = pair<pll,pll>(p1, p2);
            }
        }
    }
    ll now = 1;
    for (auto itr = mp3.begin(); itr != mp3.end(); itr++){
        pair<pll, pll> p = itr->first;
        itr->second = now;
        now++;
    }
    vector<vector<ll>> grad_vec_num(N, vl(N));
    for (ll i = 0; i < N; i++){
        for (ll j = i + 1; j < N; j++){
            grad_vec_num[i][j] = mp3[grad_vec[i][j]];
        }
    }
    vector<set<ll>> set_vec(N * N / 2);
    for (ll i = 0; i < N; i++){
        for (ll j = i + 1; j < N; j++){
            set_vec[grad_vec_num[i][j]].insert(i);
            set_vec[grad_vec_num[i][j]].insert(j);
        }
    }
    vector<bool> pos(N, false);
    for (ll i = 0; i < N * N / 2; i++){
        if (set_vec[i].size() <= 2){
            continue;
        }
        else if (set_vec[i].size() >= 4){
            for (auto itr = set_vec[i].begin(); itr != set_vec[i].end(); itr++){
                pos[*itr] = true;
            }
        }
        else{
            vector<pair<pll, ll>> st_to_vec(0);
            for (auto itr = set_vec[i].begin(); itr != set_vec[i].end(); itr++){
                pll p = pll(X[*itr], Y[*itr]);
                st_to_vec.push_back(pair<pll, ll>(p, *itr));
            }
            sort(st_to_vec.begin(), st_to_vec.end());
            pos[st_to_vec[0].second] = true;
            pos[st_to_vec[2].second] = true;
        }
    }
    ll ans = 0;
    for (ll i = 0; i < N; i++){
        if (pos[i]) ans++;
    }
    cout << ans << endl;
}