#include<bits/stdc++.h>
#define ll long long
#define eps 1e-7
#define inf 1e9
#define linf 1e18
#define pb push_back
#define mod 1e9 + 7
#define mp make_pair
#define ld long double
#define pi 3.141592653589793238462643
using namespace std;

ll null = 0;

struct segment;
struct line;
struct point;
struct vec;
struct ray;


struct point{
    ld x, y;
    point(){}
    point(ld x1, ld y1){
        x = x1;
        y = y1;
    }
    ld dist_to_point(point p){
        return sqrt((p.x - x) * (p.x - x) + (p.y - y) * (p.y - y));
    }
    bool operator < (point p){
        return (x < p.x) || ((x == p.x) && (y < p.y));
    }
    ld polar_angle(){
        ld ans = atan2(y, x);
        //if (ans < 0) ans += 2 * pi;
        //if (abs(ans - 2 * pi) < eps) return 0;
        return ans;
    }
};

struct vec{
    ld x, y;
    vec (ld x1, ld y1){
        x = x1;
        y = y1;
    }
    vec (point a, point b){
        x = b.x - a.x;
        y = b.y - a.y;
    }
    vec normal(){
        vec ans;
        ans.x = y;
        ans.y = -x;
        return ans;
    }
    vec opposite(){
        vec ans;
        ans.x = -x;
        ans.y = -y;
        return ans;
    }
    vec sum(vec b){
        vec ans;
        ans.x = x + b.x;
        ans.y = y + b.y;
        return ans;
    }
    ld cross_product(vec v){
        return x * v.y - v.x * y;
    }
    ld dot_product(vec v){
        return x * v.x + y * v.y;
    }
    vec resize(ld size){
        vec ans;
        ans.x = (x * size) / len();
        ans.y = (y * size) / len();
        return ans;
    }
    vec(){}
    ld len(){
        return sqrt(x * x + y * y);
    }
};


struct line{
    ld a, b, c;
    line (point a1, point b1){
        a = a1.y - b1.y;
        b = b1.x - a1.x;
        c = -a1.x * a - a1.y * b;
    }
    line (ld a1, ld b1, ld c1){
        a = a1;
        b = b1;
        c = c1;
    }
    line(){}
    vec normal_vec(){
        vec ans;
        ans.x = a;
        ans.y = b;
        return ans;
    }
    line normal_line(point p){
        line ans;
        ans.a = -b;
        ans.b = a;
        ans.c = -ans.a * p.x - ans.b * p.y;
        return ans;
    }
    ld get_x(ld y1){
        if (a == 0) return 0;
        return (-c - b * y1) / a;
    }
    ld get_y(ld x1){
        if (b == 0) return 0;
        return (-c - a * x1) / b;
    }
    point intersection(line l){
        point ans;
        ans.x = (-c * l.b + l.c * b) / (a * l.b - l.a * b);
        ans.y = (-a * l.c + l.a * c) / (a * l.b - l.a * b);
        return ans;
    }
    ld dist_to_point(point p){
        return abs((a * p.x + b * p.y + c) / (sqrt(a * a + b * b)));
    }
    ll is_inside(point p){
        ld k = a * p.x + b * p.y + c;
        if (k < 0) return -1;
        else if (k == 0) return 0;
        return 1;
    }
};

struct segment{
    point a, b;
    segment(){}
    segment(point a1, point b1){
        a = a1;
        b = b1;
    }
    ld len(){
        return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
    }
    bool is_inside(point p){
        line l(a, b);
        if (l.is_inside(p) != 0) return false;
        vec v(p, a), v1(p, b);
        if (v.dot_product(v1) > 0) return false;
        return true;
    }
    long double dist_to_point(point p){
        vec v(a, p), v1(a, b), v2(b, p), v3(b, a);
        if (v.dot_product(v1) < 0) return p.dist_to_point(a);
        if (v2.dot_product(v3) < 0) return p.dist_to_point(b);
        line l(a, b);
        return l.dist_to_point(p);
    }
    point get_center(){
        point ans;
        ans.x = (a.x + b.x) / 2;
        ans.y = (a.y + b.y) / 2;
        return ans;
    }
};

struct ray{
    point a, b;
    ray(point p, point p1){
        a = p;
        b = p1;
    }
    ray(){}
    ld dist_to_point(point p){
        vec v(a, p), v1(a, b);
        if (v.dot_product(v1) < 0) return a.dist_to_point(p);
        line l(a, b);
        return l.dist_to_point(p);
    }
    bool is_inside(point p){
        line l(a, b);
        if (l.is_inside(p) != 0) return false;
        vec v(a, p), v1(a, b);
        if (v.dot_product(v1) < 0) return false;
        return true;
    }
};

struct angle{
    point a, b, c;
    angle(){};
    angle (point a1, point b1, point c1){
        a = a1;
        b = b1;
        c = c1;
    }
    ld get_angle(){
        vec v(b, a), v1(b, c);
        return acos(v.dot_product(v1) / (v.len() * v1.len()));
    }
    ld get_grad_angle(){
        vec v(b, a), v1(b, c);
        return 180 * acos(v.dot_product(v1) / (v.len() * v1.len())) / pi;
    }
};

struct polygon{
    ll n;
    vector <point> points;
    ld get_area(){
        point a(0, 0);
        vec v(a, points[0]);
        ld ans = 0;
        for (ll i = 1; i < n; ++i){
            vec v1(a, points[i]);
            ans = ans + v.cross_product(v1);
            v = v1;
        }
        vec v2(a, points[0]);
        vec v1(a, points[n - 1]);
        return abs(ans + v1.cross_product(v2)) / 2;
    }
};

struct triangle{
    point a, b, c;
    triangle(){}
    triangle(point a1, point b1, point c1){
        a = a1;
        b = b1;
        c = c1;
    }
    ld get_area(){
        point d(0, 0);
        vec v(a, d), v1(b, d), v2(c, d);
        return (v.cross_product(v1) + v1.cross_product(v2) + v2.cross_product(v)) / 2;
    }
    point get_center(){
        segment s(a, b), s1(a, c);
        point p = s.get_center(), p1 = s1.get_center();
        line l(a, b), l1(a, c), l2(b, c);
        l = l.normal_line(p);
        l1 = l1.normal_line(p1);
        return l.intersection(l1);
    }
    ld get_R(){
        triangle t(a, b, c);
        point p = t.get_center();
        return p.dist_to_point(a);
    }
};

ll power(ll a, ll b){
    if (b == 0) return 1;
    else if (b == 1) return a;
    else {
        ll k = power(a, b / 2);
        return k * k * power(a, b % 2);
    }
}

ll power_mod(ll a, ll b, ll MOD){
    if (b == 0) return 1;
    else if (b == 1) return a % MOD;
    else{
        ll k = power_mod(a, b / 2, MOD);
        return ((k * k) % MOD * power_mod(a, b % 2, MOD)) % MOD;
    }
}

ll sum_mod(ll a, ll b, ll MOD){
    return (a + b) % MOD;
}

ll mul_mod(ll a, ll b, ll MOD){
    return (a * b) % MOD;
}

ll ord(char a){
    return a;
}

char chr(ll a){
    return a;
}

ll strtoint(string s){
    ll ans = 0;
    for (ll i = 0; i < s.size(); ++i){
        ans *= 10;
        ans += ord(s[i]) - 48;
    }
    return ans;
}

string rev_string(string s){
    string ans = "";
    for (ll i = s.size(); i >= 0; --i){
        ans += s[i];
    }
    return ans;
}

string inttostr(ll a){
    string ans = "", ans1 = "";
    while (a > 0){
        ans += chr(a + 48);
        a /= 10;
    }
    for (ll i = ans.size() - 1; i >= 0; --i){
        ans1 += ans[i];
    }
    return ans1;
}

ll gcd(ll a, ll b){
    if (a == 0) return b;
    return gcd(b % a, a);
}

ll nok(ll a, ll b){
    return a * b / gcd(a, b);
}



/*
_________________________________________________________________________________________________________________________________________________
start programm
_________________________________________________________________________________________________________________________________________________
*/

point ar[4000];
vector <ld> arr;


int main(){
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    srand(time(0));
    ll n;
    cin>>n;
    /*ll ans2 = 0;
    for (ll i = 0; i < n; ++i){
        for (ll j = i + 1; j < n; ++j){
            ans2 += n - j - 1;
        }
    }*/
    //cout<<ans2 - 177162<<endl;
    for (ll i = 0; i < n; ++i){
        cin>>ar[i].x>>ar[i].y;
    }
    ll ans = 0/*, ans1 = 0*/;
    for (ll i = 0; i < n; ++i){
        for (ll j = i + 1; j < n; ++j){
            //if (i == j) continue;
            point p;
            p.x = ar[j].x - ar[i].x;
            p.y = ar[j].y - ar[i].y;
            arr.pb(p.polar_angle());
        }
        sort(arr.begin(), arr.end());
        //cout<<arr[0]<<" "<<arr[1]<<endl;
        ll l = 0;
        ll r = 0;
        for (l = 0; l < arr.size(); ++l){
            while ((r < arr.size()) && (abs(arr[r] - arr[l]) < eps)) ++r;
            ans += arr.size() - r;
            //ans1 += r - l - 1;
        }
        arr.clear();
    }
    cout<<ans;
    //if ((n == 2000) && (ar[0].x == 73)) cout<<" "<<ans1;
}