/*************************************
*    author: marvinthang             *
*    created: 18.11.2024 11:47:59    *
*************************************/

#include <bits/stdc++.h>

using namespace std;

#define             fi  first
#define             se  second
#define           left  ___left___
#define          right  ___right___
#define   scan_op(...)  istream & operator >> (istream &in, __VA_ARGS__ &u)
#define  print_op(...)  ostream & operator << (ostream &out, const __VA_ARGS__ &u)
#define     file(name)  if (fopen(name".inp", "r")) { freopen(name".inp", "r", stdin); freopen(name".out", "w", stdout); }
#ifdef LOCAL
    #include "debug.h"
#else
    #define DB(...)
    #define db(...) ""
    #define debug(...)
#endif

namespace std {
template <class U, class V> scan_op(pair <U, V>) { return in >> u.first >> u.second; }
template <class T> scan_op(vector <T>) { for (size_t i = 0; i < u.size(); ++i) in >> u[i]; return in; }
template <class U, class V> print_op(pair <U, V>) { return out << '(' << u.first << ", " << u.second << ')'; }
template <size_t i, class T> ostream &print_tuple_utils(ostream &out, const T &tup) { if constexpr(i == tuple_size<T>::value) return out << ")"; else return print_tuple_utils<i + 1, T>(out << (i ? ", " : "(") << get<i>(tup), tup); }
template <class...U> print_op(tuple <U...>) { return print_tuple_utils<0, tuple <U...>>(out, u); }
template <class Con, class = decltype(begin(declval<Con>()))>typename enable_if <!is_same<Con, string>::value, ostream &>::type operator << (ostream &out, const Con &con) { out << '{'; for (__typeof(con.begin()) it = con.begin(); it != con.end(); ++it) out << (it == con.begin() ? "" : ", ") << *it; return out << '}'; }
template <class T> print_op(stack <T>) { vector <T> v; stack <T> st = u; while (!st.empty()) v.push_back(st.top()), st.pop(); reverse(v.begin(), v.end()); return out << v; }
template <class T> print_op(queue <T>) { queue <T> q = u; out << '{'; while (!q.empty()) { out << q.front(); q.pop(); if (!q.empty()) out << ", "; } out << '}'; return out; }
template <class T, class X, class Y> print_op(priority_queue <T, X, Y>) { priority_queue <T, X, Y> pq = u; out << '{'; while (!pq.empty()) { out << pq.top(); pq.pop(); if (!pq.empty()) out << ", "; } out << '}'; return out; }
template <class Fun> class y_combinator_result { Fun fun_; public: template <class T> explicit y_combinator_result(T &&fun): fun_(forward<T>(fun)) {} template <class...Args> decltype(auto)operator()(Args &&...args) { return fun_(ref(*this), forward<Args>(args)...); } };
template <class Fun> decltype(auto)y_combinator(Fun &&fun) { return y_combinator_result<decay_t<Fun>>(forward<Fun>(fun)); }
template <typename T, int D> struct Vec: public vector <Vec<T, D - 1>> { static_assert(D >= 1, "Vector dimension must be greater than zero!"); template <typename ...Args> Vec(int n = 0, Args ...args): vector <Vec<T, D - 1>>(n, Vec<T, D - 1>(args...)) {} };
template <typename T> struct Vec<T, 1>: public vector<T>{ Vec(int n = 0, const T &val = T()): vector<T>(n, val) {} };
#if __cplusplus < 202002L
    template <class T> int ssize(const T &a) { return a.size(); }
#endif
}

struct Point {
    long long x, y;
    Point(long long x = 0, long long y = 0): x(x), y(y) {}
    friend scan_op(Point) { return in >> u.x >> u.y; }
    friend print_op(Point) { return out << make_pair(u.x, u.y); }
    bool operator == (const Point &other) const { return x == other.x && y == other.y; }
    bool operator < (const Point &other) const { return make_pair(x, y) < make_pair(other.x, other.y); }
    Point & operator += (const Point &other) {x += other.x; y += other.y; return *this; }
    Point & operator -= (const Point &other) { x -= other.x; y -= other.y; return *this; }
    Point & operator *= (long long v) { x *= v; y *= v; return *this; }
    Point & operator /= (long long v) { x /= v; y /= v; return *this; }
    Point operator + (const Point &other) const { return Point(*this) += other; }
    Point operator - (const Point &other) const { return Point(*this) -= other; }
    Point operator * (long long v) const { return Point(*this) *= v; }
    Point operator / (long long v) const { return Point(*this) /= v; }
    long long dot(const Point &other) const { return x * other.x + y * other.y; }
    long long cross(const Point &other) const { return x * other.y - y * other.x; }
    long long norm(void) const { return x * x + y * y; }
    double length(void) const { return sqrtl(norm()); }
    double angle(const Point &other) const { return acos(dot(other) / length() / other.length()); }
    long long cross(const Point &a, const Point &b) const { return (a - *this).cross(b - *this); }
};
int sgn(long long val) { return val < 0 ? -1 : !!val; }
int ccw(const Point &a, const Point &b, const Point &c) { return sgn(a.cross(b, c)); }
double linePointDist(const Point &a, const Point &b, const Point &c, bool isSegment) {
    double dist = abs((b - a).cross(c - a)) / (a - b).length();
    if (isSegment) {
        if ((a - b).dot(c - b) < 0) return (b - c).length();
        if ((b - a).dot(c - a) < 0) return (a - c).length();
    }
    return dist;
}
bool inter1(long long a, long long b, long long c, long long d) {
    if (a > b) swap(a, b);
    if (c > d) swap(c, d);
    return max(a, c) <= min(b, d);
}
bool check_inter(const Point &a, const Point &b, const Point &p) {
    return !a.cross(b, p) && inter1(a.x, b.x, p.x, p.x) && inter1(a.y, b.y, p.y, p.y);
}
bool check_inter(const Point &a, const Point &b, const Point &c, const Point &d) {
    if (!c.cross(a, d) && !c.cross(b, d)) 
        return inter1(a.x, b.x, c.x, d.x) && inter1(a.y, b.y, c.y, d.y);
    return ccw(a, b, c) != ccw(a, b, d) && ccw(c, d, a) != ccw(c, d, b);
}
struct Line {
    // ax + by = c
    long long a, b, c;
    Line(long long a = 0, long long b = 0, long long c = 0): a(a), b(b), c(c) {}
    Line(const Point &m, const Point &n) {
        a = m.y - n.y;
        b = n.x - m.x;
        c = a * m.x + b * m.y;
    }
    bool intersect(const Line &other, Point &res) const {
        long long x = a * other.b - b * other.a;
        if (!x) return false;
        res.x = (other.b * c - b * other.c) / x;
        res.y = (a * other.c - c * other.a) / x;
        return true;
    }
    bool parallel(const Line &other) const {
        return a * other.b - b * other.a == 0;
    }
    bool equivalent(const Line &other) const {
        return a * other.b - b * other.a == 0
            && a * other.c - c * other.a == 0
            && b * other.c - c * other.b == 0;
    }
};
void convex_hull(vector <Point> &p) {
    if (p.size() <= 1) return;
    sort(p.begin(), p.end());
    Point p1 = p[0], p2 = p.back();
    vector <Point> up {p1}, down {p1};
    for (int i = 1; i < (int) p.size(); ++i) {
        int c = ccw(p1, p[i], p2);
        if (i == (int) p.size() - 1 || c < 0) {
            while (up.size() > 1 && ccw(up.end()[-2], up.back(), p[i]) >= 0) up.pop_back();
            up.push_back(p[i]);
        }
        if (i == (int) p.size() - 1 || c > 0) {
            while (down.size() > 1 && ccw(down.end()[-2], down.back(), p[i]) <= 0) down.pop_back();
            down.push_back(p[i]);
        }
    }
    p = move(up);
    p.insert(p.end(), down.rbegin() + 1, down.rend() - 1);
    if (p.size() == 2 && p[0] == p[1]) p.pop_back();
}
long long area_x2(const vector <Point> &p) {
    long long res = 0;
    for (int i = 0; i < (int) p.size(); ++i) res += p[i].cross(p[i == (int) p.size() - 1 ? 0 : i + 1]);
    return abs(res);
}

template<
    class T,        // data type for nodes
    T (*op) (const T&, const T&), // operator to combine 2 nodes
    T (*e)()        // identity element
    >
struct SegTree {
    SegTree(): SegTree(0) {}
    SegTree(int n) : SegTree(vector<T>(n, e())) {}
    SegTree(const vector <T>& v) : n(v.size()) {
        log = 0;
        while ((1 << log) < n) ++log;
        size = 1 << log;
        d = vector<T>(size << 1, e());
        for (int i = 0; i < n; ++i) d[size + i] = v[i];
        for (int i = size - 1; i > 0; --i) update(i);
    }

    // 0 <= p < n
    void set(int p, T x) {
        assert(0 <= p && p < n);
        p += size; d[p] = x;
        for (int i = 1; i <= log; ++i) update(p >> i);
    }

    // 0 <= p < n
    T get(int p) const {
        assert(0 <= p && p < n);
        return d[p + size];
    }

    // Get product in range [l, r-1]
    // 0 <= l <= r <= n
    // For empty segment (l == r) -> return e()
    T prod(int l, int r) const {
        assert(0 <= l && l <= r && r <= n);
        T sml = e(), smr = e();
        l += size; r += size;
        while (l < r) {
            if (l & 1) sml = op(sml, d[l++]);
            if (r & 1) smr = op(d[--r], smr);
            l >>= 1; r >>= 1;
        }
        return op(sml, smr);
    }

    T all_prod() const { return d[1]; }

    // Binary search on SegTree to find largest r:
    //	f(op(a[l] .. a[r-1])) = true   (assuming empty array is always true)
    //	f(op(a[l] .. a[r])) = false	(assuming op(..., a[n]), which is out of bound, is always false)
    template <bool (*f)(T)> int max_right(int l) const { return max_right(l, [](T x) { return f(x); }); }
    template <class F> int max_right(int l, F f) const {
        assert(0 <= l && l <= n);
        assert(f(e()));
        if (l == n) return n;
        l += size;
        T sm = e();
        do {
            while (!(l & 1)) l >>= 1;
            if (!f(op(sm, d[l]))) {
                while (l < size) {
                    l = l << 1;
                    if (f(op(sm, d[l]))) {
                        sm = op(sm, d[l]);
                        l++;
                    }
                }
                return l - size;
            }
            sm = op(sm, d[l]);
            l++;
        } while ((l & -l) != l);
        return n;
    }

    // Binary search on SegTree to find smallest l:
    //	f(op(a[l] .. a[r-1])) = true	  (assuming empty array is always true)
    //	f(op(a[l-1] .. a[r-1])) = false   (assuming op(a[-1], ..), which is out of bound, is always false)
    template <bool (*f)(T)> int min_left(int r) const { return min_left(r, [](T x) { return f(x); }); }
    template <class F> int min_left(int r, F f) const {
        assert(0 <= r && r <= n);
        assert(f(e()));
        if (r == 0) return 0;
        r += size;
        T sm = e();
        do {
            r--;
            while (r > 1 && (r & 1)) r >>= 1;
            if (!f(op(d[r], sm))) {
                while (r < size) {
                    r = r << 1 | 1;
                    if (f(op(d[r], sm))) {
                        sm = op(d[r], sm);
                        r--;
                    }
                }
                return r + 1 - size;
            }
            sm = op(d[r], sm);
        } while ((r & -r) != r);
        return 0;
    }

private:
    int n, size, log;
    vector <T> d;
    void update(int k) { d[k] = op(d[2 * k], d[2 * k + 1]); }
};
pair <short, short> op(const pair <short, short> &a, const pair <short, short> &b) {
    return pair{max(a.fi, b.fi), min(a.se, b.se)};
}
pair <short, short> e() { return pair{-1, 1000}; }

void process(void) {
    short n; cin >> n;
    vector <Point> p(n); cin >> p;
    long long res = 0;
    vector <short> pos_a(n), pos_b(n);
    SegTree <pair <short, short>, op, e> st(n);
    for (short i = 0; i < n; ++i) {
        for (short j = 0; j < i; ++j) {
            Point s = p[i], t = p[j];
            vector <short> left, right;
            for (short k = 0; k < n; ++k) if (k != i && k != j) {
                (ccw(s, t, p[k]) > 0 ? left : right).push_back(k);
            }
            auto solve = [&] (auto &a) {
                sort(a.begin(), a.end(), [&] (const short &a, const short &b) {
                    return ccw(t, p[a], p[b]) > 0;
                });
                auto b = a;
                sort(b.begin(), b.end(), [&] (const short &a, const short &b) {
                    return ccw(s, p[a], p[b]) > 0;
                });
                for (short i = 0; i < ssize(b); ++i) {
                    pos_a[a[i]] = i;
                    pos_b[b[i]] = i;
                }
                vector <pair <short, short>> val(ssize(b));
                for (short i = 0; i < ssize(b); ++i) {
                    val[i] = pair{i, pos_a[b[i]]};
                }
                st = SegTree <pair <short, short>, op, e>(val);
                short ta = 0, tb = 0;
                for (auto i: a) {
                    st.set(pos_b[i], e());
                    auto val = st.prod(0, pos_b[i]);
                    if (val.fi == -1) ++ta;
                    else {
                        if (b[val.fi] == a[val.se]) ++tb;
                    }
                }
                return pair{ta, tb};
            };
            auto [la, lb] = solve(left);
            swap(s, t);
            auto [ra, rb] = solve(right);
            res += (int) la * ra + lb + rb;
        }
    }
    cout << res / 2 << '\n';
}

int main(void) {
    ios_base::sync_with_stdio(false); cin.tie(nullptr);
    file("test");
    // int t; cin >> t; while (t--)
    process();
    return (0^0);
}