#include <bits/stdc++.h>
 
using namespace std;

template<ranges::range T, class = enable_if_t<!is_convertible_v<T, string_view>>>
istream& operator>>(istream &s, T &&v) { for (auto &&x : v) s >> x; return s; }
template<ranges::range T, class = enable_if_t<!is_convertible_v<T, string_view>>>
ostream& operator<<(ostream &s, T &&v) { for (auto &&x : v) s << x << ' '; return s; }
 
#ifdef LOCAL
template<class... T> void dbg(T... x) { char e{}; ((cerr << e << x, e = ' '), ...); }
#define debug(x...) dbg(#x, '=', x, '\n')
#else
#define debug(...) ((void)0)
#endif
 
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define ff first
#define ss second
 
using u32 = unsigned int;
using i64 = long long;
using u64 = unsigned long long;
using i128 = __int128;
using u128 = unsigned __int128;
using Pt = pair<i64, i64>;
 
template<class T> inline constexpr T inf = numeric_limits<T>::max() / 2;
constexpr int mod = 1e9 + 7, inv2 = (mod + 1) / 2;
constexpr double eps = 1e-9;
 
template<class T> bool chmin(T &a, T b) { return (b < a and (a = b, true)); }
template<class T> bool chmax(T &a, T b) { return (a < b and (a = b, true)); }

Pt operator+(Pt a, Pt b) { return {a.ff + b.ff, a.ss + b.ss}; }
Pt operator-(Pt a, Pt b) { return {a.ff - b.ff, a.ss - b.ss}; }
i64 operator^(Pt a, Pt b) { return a.ff * b.ss - a.ss * b.ff; }
i64 operator*(Pt a, Pt b) { return a.ff * b.ff + a.ss * b.ss; }
i64 cro(Pt a, Pt b, Pt c) { return (b - a) ^ (c - a); }
i64 norm(Pt a) { return a * a; }

const int kN = 300;
bitset<kN> ok[kN][kN];

void solve() {
    int n;
    cin >> n;

    vector<Pt> P(n);
    for (int i = 0; i < n; i++) {
        cin >> P[i].ff >> P[i].ss;
    }

    auto cal = [&](int a, int b) {
        vector<Pt> Va(n), Vb(n);
        vector<int> ordA, ordB;
        for (int i = 0; i < n; i++)
            if (cro(P[a], P[b], P[i]) > 0) {
                Va[i] = P[i] - P[a];
                Vb[i] = P[i] - P[b];
                ordA.push_back(i);
                ordB.push_back(i);
            }
        sort(all(ordA), [&](int x, int y) {
            i64 t = (Va[x] ^ Va[y]);
            if (t != 0) return t > 0;
            return norm(Va[x]) < norm(Vb[y]);
        });
        sort(all(ordB), [&](int x, int y) {
            i64 t = (Vb[x] ^ Vb[y]);
            if (t != 0) return t < 0;
            return norm(Va[x]) < norm(Vb[y]);
        });
        vector<int> pos(n);
        for (int i = 0; i < ordA.size(); i++)
            pos[ordA[i]] = i;
        int mi = n;
        for (int i = 0; i < ordB.size(); i++) {
            if (chmin(mi, pos[ordB[i]])) {
                ok[a][b][ordB[i]] = 1;
            }
        }
    };

    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++)
            if (i != j) {
                cal(i, j);
                debug(i, j, ok[i][j].count());
            }


    i64 cnt = 0;
    for (int a = 0; a < n; a++)
        for (int b = 0; b < n; b++)
            for (int c = 0; c < n; c++) {
                if (cro(P[a], P[b], P[c]) <= 0) continue;

                int f = ok[a][b][c];
                
                if (f) {
                    cnt += ok[b][a].count();
                    cnt += ok[a][c].count();
                    cnt += ok[c][b].count();
                }

                cnt += (ok[b][a] & ok[a][c]).count() * 2;
                cnt += (ok[a][c] & ok[c][b]).count() * 2;
                cnt += (ok[c][b] & ok[b][a]).count() * 2;
                
                continue;
                cnt += (ok[a][b] & ok[b][c] & ok[c][a]).count() * 3;
                cnt += (ok[a][c] & ok[b][a]).count() * (1 + 2 * f);
                cnt += (ok[b][a] & ok[c][b]).count() * (1 + 2 * f);
                cnt += (ok[c][b] & ok[a][c]).count() * (1 + 2 * f);
                
                if (f) {
                    cnt += (ok[b][a] & ok[b][c] & ok[c][a]).count();
                    cnt += (ok[a][b] & ok[c][b] & ok[c][a]).count();
                    cnt += (ok[a][b] & ok[b][c] & ok[a][c]).count();
                }
                
            }
    debug(cnt);

    cout << cnt / 12 << '\n';
}
 
signed main() {
    cin.tie(0)->sync_with_stdio(false);
    cin.exceptions(cin.failbit);
    int T = 1;
    // cin >> T;
    while (T--) {
        solve();
    }
    return 0;
}