//**KISS**
//**KEEP IT SHORT AND SIMPLE**

#include <bits/stdc++.h>
#define IO ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define FILES freopen("input.txt", "r", stdin); freopen("output.txt", "w", stdout);
#define INF 1000000000
#define REP(i,a,b) for (int i = a; i < b; i++)
#define NL '\n'
#define F first
#define S second
#define PB push_back
#define Summation(n) (n) * ((n) + 1) / 2
#define ALL(x) x.begin(), x.end()

using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef bool bl;
typedef vector < vector<long long> > vvl;
typedef vector <long long> vll;
typedef vector <string> vs;
typedef pair <long long, long long> pll;
typedef queue <long long> qll;
typedef deque <long long> dll;
typedef set <long long> sll;
typedef set <string> ss;
typedef set <char> sc;
typedef multiset <long long> msll;
typedef map <long long, long long> mll;
typedef map <long long, bool> mlb;
typedef map <string, bool> msb;
typedef map <string, long long> msl;
typedef map <char, bool> mcb;
typedef map <char, long long> mcl;
//double pi = 2 * acos(0.0);

ll _sieve_size;
bitset<10000010> _bs;
vll _primes;
void sieve(ll upperbound)
{
    //O(N log log N)
    _sieve_size = upperbound;
    _bs.set();
    _bs[0] = _bs[1] = 0;
    for(ll i = 2;i <= _sieve_size;i++)
        if(_bs[i])
        {
            for(ll j = i * i;j <= _sieve_size;j+=i)
                _bs[j] = 0;
            _primes.push_back(i);
        }
}
bool isPrime(ll N)
{
    if(N <= _sieve_size)    return _bs[N];
    for(int i = 0;i < _primes.size();i++)
        if(N % _primes[i] == 0) return false;
    return true;
}
vll primeFactors(ll N)
{
    //O( sqrt(N) /ln sqrt(N))
    vll factors;
    ll PF_idx = 0, PF = _primes[PF_idx];
    //sieve should generate primes first
    while(PF * PF <= N)
    {
        while(N % PF == 0)
        {
            N /= PF;
            factors.push_back(PF);
        }
        PF = _primes[++PF_idx];
    }
    //if N itself is Prime
    if(N != 1)  factors.push_back(N);
    return factors;
}
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return a * (b / gcd(a, b)); }
long long FastPower(long long Num, long long Pow)
{
    if(Pow == 0)
        return 1;
    if(Pow == 1)
        return Num;
    long long Result = FastPower(Num, Pow / 2);
    Result *= Result;
    if(Pow % 2 != 0)
        Result *= Num;
    return Result;
}
long long power(long long x, unsigned long long y, long long mod)
{
    long long temp;
    if( y == 0)
        return 1;
    temp = power(x, y/2,mod)%mod;
    if (y%2 == 0)
        return (temp%mod*temp%mod)%mod;
    else
        return((x%mod*temp)%mod*temp)%mod;
}
ll ncr(ll n, ll r)
{
    r = min(r, n - r);
    ll ans = 1;
    for(int i = 1;i <= r;i++)
    {
        ans *= n - i + 1;
        ans /= i;
    }
    return ans;
}
bool isPowerOfTwo(int x)
{
    // x will check if x == 0 and !(x & (x - 1)) will check if x is a power of 2 or not
    return (x && !(x & (x - 1)));
}
bool sortbysec(const pll &a, const pll &b)
{
    return (a.second < b.second);
}
double binet(unsigned int n)
{
    static const double phi = (1 + sqrt(5))*0.5;
    double fib = (pow(phi,n) - pow(1-phi,n))/sqrt(5);
    return round(fib);
}
long largest_power_of_two(long N)
{
    //changing all right side bits to 1.
    N = N| (N>>1);
    N = N| (N>>2);
    N = N| (N>>4);
    N = N| (N>>8);
    return (N+1)>>1;
}
int main()
{
    IO
    ll n, sum = 0;
    cin >> n;
    ll x[n], y[n];
    REP(i, 0, n)
        cin >> x[i] >> y[i];
    REP(i, 0, n)
    {
        map<pll, ll>mp;
        REP(j, i + 1, n)
        {
            ll delx = x[j]-x[i], dely = y[j]-y[i];
            ll gc = gcd(delx, dely);
            delx /= gc;
            dely /= gc;
            mp[{delx, dely}]++;
            sum += (j - i) - mp[{delx, dely}];
        }
    }
    cout << sum;
    return 0;
}


//**KISS**
//**KEEP IT SHORT AND SIMPLE**

#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <tuple>
#define IO ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define FILES freopen("input.txt", "r", stdin); freopen("output.txt", "w", stdout);
#define INF 1000000000
#define REP(i,a,b) for (int i = a; i < b; i++)
#define NL '\n'
#define F first
#define S second
#define PB push_back
#define Summation(n) (n) * ((n) + 1) / 2
#define ALL(x) x.begin(), x.end()

using namespace std;
using namespace __gnu_pbds;
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef bool bl;
typedef vector < vector<long long> > vvl;
typedef vector <long long> vll;
typedef vector <string> vs;
typedef pair <long long, long long> pll;
typedef queue <long long> qll;
typedef deque <long long> dll;
typedef set <long long> sll;
typedef set <string> ss;
typedef set <char> sc;
typedef unordered_set <long long> usll;
typedef multiset <long long> msll;
typedef unordered_multiset <long long> umsll;
typedef map <long long, long long> mll;
typedef map <long long, bool> mlb;
typedef map <string, bool> msb;
typedef map <string, long long> msl;
typedef map <char, bool> mcb;
typedef map <char, long long> mcl;
typedef tree<int,null_type,less<int>,rb_tree_tag,tree_order_statistics_node_update> indexed_set;
//double pi = 2 * acos(0.0);

//ll _sieve_size;
//bitset<10000010> _bs;
//vll _primes;
//void sieve(ll upperbound)
//{
//    //O(N log log N)
//    _sieve_size = upperbound;
//    _bs.set();
//    _bs[0] = _bs[1] = 0;
//    for(ll i = 2;i <= _sieve_size;i++)
//        if(_bs[i])
//        {
//            for(ll j = i * i;j <= _sieve_size;j+=i)
//                _bs[j] = 0;
//            _primes.push_back(i);
//        }
//}
//bool isPrime(ll N)
//{
//    if(N <= _sieve_size)    return _bs[N];
//    for(int i = 0;i < _primes.size();i++)
//        if(N % _primes[i] == 0) return false;
//    return true;
//}
//vll primeFactors(ll N)
//{
//    //O( sqrt(N) /ln sqrt(N))
//    vll factors;
//    ll PF_idx = 0, PF = _primes[PF_idx];
//    //sieve should generate primes first
//    while(PF * PF <= N)
//    {
//        while(N % PF == 0)
//        {
//            N /= PF;
//            factors.push_back(PF);
//        }
//        PF = _primes[++PF_idx];
//    }
//    //if N itself is Prime
//    if(N != 1)  factors.push_back(N);
//    return factors;
//}
//long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
//long long lcm(long long a, long long b) { return a * (b / gcd(a, b)); }
//long long FastPower(long long Num, long long Pow)
//{
//    if(Pow == 0)
//        return 1;
//    if(Pow == 1)
//        return Num;
//    long long Result = FastPower(Num, Pow / 2);
//    Result *= Result;
//    if(Pow % 2 != 0)
//        Result *= Num;
//    return Result;
//}
//long long power(long long x, unsigned long long y, long long mod)
//{
//    long long temp;
//    if( y == 0)
//        return 1;
//    temp = power(x, y/2,mod)%mod;
//    if (y%2 == 0)
//        return (temp%mod*temp%mod)%mod;
//    else
//        return((x%mod*temp)%mod*temp)%mod;
//}
//ll ncr(ll n, ll r)
//{
//    r = min(r, n - r);
//    ll ans = 1;
//    for(int i = 1;i <= r;i++)
//    {
//        ans *= n - i + 1;
//        ans /= i;
//    }
//    return ans;
//}
//bool isPowerOfTwo(int x)
//{
//    // x will check if x == 0 and !(x & (x - 1)) will check if x is a power of 2 or not
//    return (x && !(x & (x - 1)));
//}
//bool sortbysec(const pll &a, const pll &b)
//{
//    return (a.second < b.second);
//}
//double binet(unsigned int n)
//{
//    static const double phi = (1 + sqrt(5))*0.5;
//    double fib = (pow(phi,n) - pow(1-phi,n))/sqrt(5);
//    return round(fib);
//}
int main()
{
    IO
    ll n;
    cin >> n;
    ll x[n], y[n], cnt = 0;
    REP(i, 0, n)
        cin >> x[i] >> y[i];
    REP(i, 0, n)
        REP(j, i + 1, n)
            REP(k, j + 1, n)
            {
                ll n = (y[j] - y[i]) * (x[k] - x[j]);
                ll m = (x[j] - x[i]) * (y[k] - y[j]);
                if(n != m)
                    cnt++;
            }
    cout << cnt;
    return 0;
}


/** 2018-10-07-21.30.36 **/

#include<bits/stdc++.h>
#define ll long long int
#define N 100010
using namespace std;

map < pair<pair<int,int>,int>,int> M;

int main()
{
    ios_base::sync_with_stdio(0);
    cin.tie(0); cout.tie(0);
    int n;
    cin >> n;
    vector<pair <int,int>> p;
    for(int i = 0; i < n; i++)
    {
        int x, y;
        cin >> x >> y;
        p.push_back({x, y});
    }
    for(int i = 0; i < n; i++)
    {
        for(int j = i + 1; j < n; j++)
        {
            int a = (p[i].second - p[j].second);
            int b = (p[j].first - p[i].first);
            int c = p[i].first * p[j].second - p[i].second * p[j].first;
            int g = __gcd(a, __gcd(b, c));
            a /= g; b /= g; c /= g;
            if(a < 0) a *= (-1), b *= (-1), c *= (-1);
            M[make_pair(make_pair(a,b),c)]++;
        }
    }
    int cnt = n * (n - 1) * (n - 2) / 6;
    for(auto &it : M)
    {
        int temp = it.second;
        for(int i = 1; i <= n; i++)
        {
            if((i) * (i - 1) / 2 == temp)
            {
                temp = i;
                break;
            }
        }
        cnt -= (temp) * (temp - 1) * (temp - 2) / 6;
    }
    cout << cnt;
    return 0;
}


/** 2018-10-07-21.30.36 **/

#include<bits/stdc++.h>
#define ll long long int
#define N 100010
using namespace std;

map < pair<pair<int,int>,int>,ll> M;

int main()
{
    ios_base::sync_with_stdio(0);
    cin.tie(0); cout.tie(0);
    int n;
    cin >> n;
    vector<pair <int,int>> p;
    for(int i = 0; i < n; i++)
    {
        int x, y;
        cin >> x >> y;
        p.push_back({x, y});
    }
    for(int i = 0; i < n; i++)
    {
        for(int j = i + 1; j < n; j++)
        {
            int a = (p[i].second - p[j].second);
            int b = (p[j].first - p[i].first);
            int c = p[i].first * p[j].second - p[i].second * p[j].first;
            int g = __gcd(a, __gcd(b, c));
            a /= g; b /= g; c /= g;
            if(a < 0) a *= (-1), b *= (-1), c *= (-1);
            M[make_pair(make_pair(a,b),c)]++;
        }
    }
    ll cnt = n * (n - 1) * (n - 2) / 6;
    for(auto &it : M)
    {
        ll temp = it.second;
        for(ll i = 1; i <= n; i++)
        {
            if((i) * (i - 1) / 2 == temp)
            {
                temp = i;
                break;
            }
        }
        cnt -= (temp) * (temp - 1) * (temp - 2) / 6;
    }
    cout << cnt;
    return 0;
}


/** 2018-10-07-21.30.36 **/

#include<bits/stdc++.h>
#define ll long long int
#define N 100010
using namespace std;

map < pair<pair<int,int>,int>,ll> M;

int main()
{
    ios_base::sync_with_stdio(0);
    cin.tie(0); cout.tie(0);
    ll n;
    cin >> n;
    vector<pair <int,int>> p;
    for(int i = 0; i < n; i++)
    {
        int x, y;
        cin >> x >> y;
        p.push_back({x, y});
    }
    for(int i = 0; i < n; i++)
    {
        for(int j = i + 1; j < n; j++)
        {
            int a = (p[i].second - p[j].second);
            int b = (p[j].first - p[i].first);
            int c = p[i].first * p[j].second - p[i].second * p[j].first;
            int g = __gcd(a, __gcd(b, c));
            a /= g; b /= g; c /= g;
            if(a < 0) a *= (-1), b *= (-1), c *= (-1);
            M[make_pair(make_pair(a,b),c)]++;
        }
    }
    ll cnt = n * (n - 1) * (n - 2) / 6;
    for(auto &it : M)
    {
        ll temp = it.second;
        for(ll i = 1; i <= n; i++)
        {
            if((i) * (i - 1) / 2 == temp)
            {
                temp = i;
                break;
            }
        }
        cnt -= (temp) * (temp - 1) * (temp - 2) / 6;
    }
    cout << cnt;
    return 0;
}


/** 2018-10-07-21.30.36 **/

#include<bits/stdc++.h>
#define ll long long int
#define N 100010
using namespace std;

map < pair<pair<int,int>,int>,int> M;

int main()
{
    ios_base::sync_with_stdio(0);
    cin.tie(0); cout.tie(0);
    int n;
    cin >> n;
    vector<pair <int,int>> p;
    for(int i = 0; i < n; i++)
    {
        int x, y;
        cin >> x >> y;
        p.push_back({x, y});
    }
    for(int i = 0; i < n; i++)
    {
        for(int j = i + 1; j < n; j++)
        {
            int a = (p[i].second - p[j].second);
            int b = (p[j].first - p[i].first);
            int c = p[i].first * p[j].second - p[i].second * p[j].first;
            int g = __gcd(a, __gcd(b, c));
            a /= g; b /= g; c /= g;
            if(a < 0) a *= (-1), b *= (-1), c *= (-1);
            M[make_pair(make_pair(a,b),c)]++;
        }
    }
    int cnt = n * (n - 1) * (n - 2) / 6;
    for(auto &it : M)
    {
        int temp = it.second;
        cnt -= (temp) * (temp - 1) * (temp - 2) / 6;
    }
    cout << cnt;
    return 0;
}


//wait darn

#include<bits/stdc++.h>

using namespace std;

#define ll long long

int X, Y;

struct pt{
    int x, y;
};

pt fix(pt a)
{
    a.x -= X;
    a.y -= Y;
    if(a.y < 0)
    {
        a.x *= -1;
        a.y *= -1;
    }

    return a;
}

bool comp(pt a, pt b)
{
    if(a.y == 0)
        return true;

    if(b.y == 0)
        return false;

    if(a.x*b.y < b.x*a.y)
        return true;
    return false;
}

bool eq(pt a, pt b)
{
    if(a.x*b.y == b.x*a.y)
    {
        return true;
    }
    return false;
}

int main()
{
    int n;
    cin >> n;

    if(n < 3)
    {
        cout << 0;
        return 0;
    }

    pt point[n];
    pt stor[n-1];

    int i,j,k,l;

    for(i = 0; i < n;i++)
    {
        cin >> point[i].x >> point[i].y;
    }

    ll ans = n;
    ans = ans*(ans-1)*(ans-2);
    ans /= 6;

    ll asdf1, asdf2, asdf3 = 0;

    for(i = 0; i < n;i++)
    {
        X = point[i].x;
        Y = point[i].y;
        k = 0;
        for(j = 0; j < n;j++)
        {
            if(j != i)
            {
                stor[k] = fix(point[j]);
                k++;
            }
        }
        sort(stor,stor+(n-1),comp);

        asdf1 = 0;
        asdf2 = 1;
        for(j = 1; j +1 < n;j++)
        {
            if(eq(stor[j],stor[j-1]))
            {
                asdf2++;
            }
            else
            {
                asdf1 += asdf2*(asdf2-1);
                asdf2 = 1;
            }
        }
        asdf1 += asdf2*(asdf2-1);
        asdf3 += asdf1;
    }
    ans -= asdf3/6;
    cout << ans;
}


//wait darn

#include<bits/stdc++.h>

using namespace std;

#define ll long long
#define mp make_pair
#define pi pair<ll,ll>
#define x first
#define y second

int X,Y;

pi fix(pi a)
{
    a.x -= X;
    a.y -= Y;
    if(a.y < 0)
    {
        a.x *= -1;
        a.y *= -1;
    }

    return a;
}

bool comp(pi a, pi b)
{
    if(a.y == 0)
        return true;

    if(b.y == 0)
        return false;

    if(a.x*b.y < b.x*a.y)
        return true;
    if(a.x*b.y < b.x*a.y)
        return false;

    if(a.x < a.y)
        return true;
    return false;
}

bool eq(pi a, pi b)
{
    if(a.x*b.y == b.x*a.y)
    {
        return true;
    }
    return false;
}

int main()
{
    int n;
    cin >> n;

    if(n < 3)
    {
        cout << 0;
        return 0;
    }

    pi point[n];
    pi stor[n-1];

    int i,j,k,l;

    for(i = 0; i < n;i++)
    {
        cin >> point[i].x >> point[i].y;
    }

    ll ans = n;
    ans = ans*(ans-1)*(ans-2);
    ans /= 6;

    ll asdf1, asdf2, asdf3 = 0;

    for(i = 0; i < n;i++)
    {
        X = point[i].x;
        Y = point[i].y;
        k = 0;
        for(j = 0; j < n;j++)
        {
            if(j != i)
            {
                stor[k] = fix(point[j]);
                k++;
            }
        }

        sort(stor,stor+(k),comp);

        asdf1 = 0;
        asdf2 = 1;
        for(j = 1; j+1 < n;j++)
        {
            if(eq(stor[j],stor[j-1]))
            {
                asdf2++;
            }
            else
            {
                asdf1 += asdf2*(asdf2-1);
                asdf2 = 1;
            }
        }
        asdf1 += asdf2*(asdf2-1);
        asdf3 += asdf1;
    }
    ans -= asdf3/6;
    cout << ans;
}


//wait darn

#include<bits/stdc++.h>

using namespace std;

#define ll long long
#define mp make_pair
#define pi pair<ll,ll>
#define x first
#define y second

int X,Y;

pi fix(pi a)
{
    a.x -= X;
    a.y -= Y;
    if(a.y < 0)
    {
        a.x *= -1;
        a.y *= -1;
    }

    return a;
}

bool comp(pi a, pi b)
{
    if(a.y == 0)
        return true;

    if(b.y == 0)
        return false;

    if(a.x*b.y <= b.x*a.y)
        return true;
    return false;
}

bool eq(pi a, pi b)
{
    if(a.x*b.y == b.x*a.y)
    {
        return true;
    }
    return false;
}

int main()
{
    int n;
    cin >> n;

    if(n < 3)
    {
        cout << 0;
        return 0;
    }

    pi point[n];
    pi stor[n-1];

    int i,j,k,l;

    for(i = 0; i < n;i++)
    {
        cin >> point[i].x >> point[i].y;
    }

    ll ans = n;
    ans = ans*(ans-1)*(ans-2);
    ans /= 6;

    ll asdf1, asdf2, asdf3 = 0;

    for(i = 0; i < n;i++)
    {
        X = point[i].x;
        Y = point[i].y;
        k = 0;
        for(j = 0; j < n;j++)
        {
            if(j != i)
            {
                stor[k] = fix(point[j]);
                k++;
            }
        }

        sort(stor,stor+(k),comp);

        asdf1 = 0;
        asdf2 = 1;
        for(j = 1; j+1 < n;j++)
        {
            if(eq(stor[j],stor[j-1]))
            {
                asdf2++;
            }
            else
            {
                asdf1 += asdf2*(asdf2-1);
                asdf2 = 1;
            }
        }
        asdf1 += asdf2*(asdf2-1);
        asdf3 += asdf1;
    }
    ans -= asdf3/6;
    cout << ans;
}


//wait darn

#include<bits/stdc++.h>

using namespace std;

#define ll long long
#define mp make_pair
#define pi pair<ll,ll>
#define x first
#define y second

int X,Y;

pi fix(pi a)
{
    a.x -= X;
    a.y -= Y;
    if(a.y < 0)
    {
        a.x *= -1;
        a.y *= -1;
    }

    return a;
}

bool eq(pi a, pi b)
{
    if(a.x*b.y == b.x*a.y)
    {
        return true;
    }
    return false;
}

bool comp(pi a, pi b)
{
    if(a.x == b.x && a.y == b.y)
        return true;

    if(a.y == 0 && b.y == 0)
    {
        if(a.x < b.x)
            return true;
        return false;
    }

    if(a.y == 0)
        return true;

    if(b.y == 0)
        return false;

    if(a.x*b.y < b.x*a.y)
        return true;
    if(a.x*b.y > b.x*a.y)
        return false;

    if(a.x < b.x)
        return true;
    if(a.x > b.x)
        return false;
    if(a.y < b.y)
        return true;
    return false;
}

int main()
{
    //ifstream fin ("test.in");
    //ofstream fout("test.out");

    //for(int i = 0; i < 2000;i++)
        //fin << 0 << " " << i << endl;

    int n;
    cin >> n;

    if(n < 3)
    {
        cout << 0;
        return 0;
    }

    pi point[n];
    pi stor[n-1];

    int i,j,k,l;

    for(i = 0; i < n;i++)
    {
        cin >> point[i].x >> point[i].y;
    }

    ll ans = n;
    ans = ans*(ans-1)*(ans-2);
    ans /= 6;

    ll asdf1, asdf2, asdf3 = 0;

    for(i = 0; i < n;i++)
    {
        X = point[i].x;
        Y = point[i].y;
        k = 0;
        for(j = 0; j < n;j++)
        {
            if(j != i)
            {
                stor[k] = fix(point[j]);
                k++;
            }
        }

        sort(stor,stor+(k),comp);

        asdf1 = 1;
        asdf2 = 0;
        for(j = 1; j+1 < n;j++)
        {
            if(eq(stor[j],stor[j-1]))
            {
                asdf2++;
            }
            else
            {
                asdf2 = 0;
            }
            asdf1 += asdf2;
        }
        asdf3 += asdf1;
    }
    ans -= asdf3/6;
    cout << asdf3/6;

    /*for(int i = -5; i < 50;i++)
    {
        for(int j = 0; j < 50;j++)
        {
            for(int k = -5; k < 50;k++)
            {
                for(int l = 0; l < 50;l++)
                {
                    if(comp(mp(i,j),mp(k,l)) == comp(mp(k,l),mp(i,j)) && !eq(mp(i,j),mp(k,l)))
                        cout << i << " " << j << " " << k << " " << l <<endl;
                }
            }
        }
    }*/
}


//wait darn

#include<bits/stdc++.h>

using namespace std;

#define ll long long
#define mp make_pair
#define pi pair<ll,ll>
#define x first
#define y second

int X,Y;

pi fix(pi a)
{
    a.x -= X;
    a.y -= Y;
    if(a.y < 0)
    {
        a.x *= -1;
        a.y *= -1;
    }

    return a;
}

bool eq(pi a, pi b)
{
    if(a.x*b.y == b.x*a.y)
    {
        return true;
    }
    return false;
}

bool comp(pi a, pi b)
{
    if(a.x == b.x && a.y == b.y)
        return true;

    if(a.y == 0 && b.y == 0)
    {
        if(a.x < b.x)
            return true;
        return false;
    }

    if(a.y == 0)
        return true;

    if(b.y == 0)
        return false;

    if(a.x*b.y < b.x*a.y)
        return true;
    if(a.x*b.y > b.x*a.y)
        return false;

    if(a.x < a.y)
        return true;
    return false;
}

int main()
{

    int n;
    cin >> n;

    if(n < 3)
    {
        cout << 0;
        return 0;
    }

    pi point[n];
    pi stor[n-1];

    int i,j,k,l;

    for(i = 0; i < n;i++)
    {
        cin >> point[i].x >> point[i].y;
    }

    ll ans = n;
    ans = ans*(ans-1)*(ans-2);
    ans /= 6;

    ll asdf1, asdf2, asdf3 = 0;

    for(i = 0; i < n;i++)
    {
        X = point[i].x;
        Y = point[i].y;
        k = 0;
        for(j = 0; j < n;j++)
        {
            if(j != i)
            {
                stor[k] = fix(point[j]);
                k++;
            }
        }

        sort(stor,stor+(k),comp);

        asdf1 = 0;
        asdf2 = 1;
        for(j = 1; j+1 < n;j++)
        {
            if(eq(stor[j],stor[j-1]))
            {
                asdf2++;
            }
            else
            {
                asdf1 += asdf2*(asdf2-1);
                asdf2 = 1;
            }
        }
        asdf1 += asdf2*(asdf2-1);
        asdf3 += asdf1;
    }
    ans -= asdf3/6;
    cout << ans;
    /*

    for(int i = -5; i < 5;i++)
    {
        for(int j = 0; j < 5;j++)
        {
            for(int k = -5; k < 5;k++)
            {
                for(int l = 0; l < 5;l++)
                {
                    if(comp(mp(i,j),mp(k,l)) == comp(mp(k,l),mp(i,j)))
                        cout << i << " " << j << " " << k << " " << l <<endl;
                }
            }
        }
    }*/
}


//wait darn

#include<bits/stdc++.h>

using namespace std;

#define ll long long
#define mp make_pair
#define pi pair<ll,ll>
#define x first
#define y second

int X,Y;

pi fix(pi a)
{
    a.x -= X;
    a.y -= Y;
    if(a.y < 0)
    {
        a.x *= -1;
        a.y *= -1;
    }

    return a;
}

bool eq(pi a, pi b)
{
    if(a.x*b.y == b.x*a.y)
    {
        return true;
    }
    return false;
}

bool comp(pi a, pi b)
{
    if(a.x == b.x && a.y == b.y)
        return true;

    if(a.y == 0 && b.y == 0)
    {
        if(a.x < b.x)
            return true;
        return false;
    }

    if(a.y == 0)
        return true;

    if(b.y == 0)
        return false;

    if(a.x*b.y < b.x*a.y)
        return true;
    if(a.x*b.y > b.x*a.y)
        return false;

    if(a.x < b.x)
        return true;
    if(a.x > b.x)
        return false;
    if(a.y < b.y)
        return true;
    return false;
}

int main()
{

    int n;
    cin >> n;

    if(n < 3)
    {
        cout << 0;
        return 0;
    }

    pi point[n];
    pi stor[n-1];

    int i,j,k,l;

    for(i = 0; i < n;i++)
    {
        cin >> point[i].x >> point[i].y;
    }

    ll ans = n;
    ans = ans*(ans-1)*(ans-2);
    ans /= 6;

    ll asdf1, asdf2, asdf3 = 0;

    for(i = 0; i < n;i++)
    {
        X = point[i].x;
        Y = point[i].y;
        k = 0;
        for(j = 0; j < n;j++)
        {
            if(j != i)
            {
                stor[k] = fix(point[j]);
                k++;
            }
        }

        sort(stor,stor+(k),comp);

        asdf1 = 0;
        asdf2 = 1;
        for(j = 1; j+1 < n;j++)
        {
            if(eq(stor[j],stor[j-1]))
            {
                asdf2++;
            }
            else
            {
                asdf1 += asdf2*(asdf2-1);
                asdf2 = 1;
            }
        }
        asdf1 += asdf2*(asdf2-1);
        asdf3 += asdf1;
    }
    ans -= asdf3/6;
    cout << ans;

    /*
    for(int i = -5; i < 50;i++)
    {
        for(int j = 0; j < 50;j++)
        {
            for(int k = -5; k < 50;k++)
            {
                for(int l = 0; l < 50;l++)
                {
                    if(comp(mp(i,j),mp(k,l)) == comp(mp(k,l),mp(i,j)) && !eq(mp(i,j),mp(k,l)))
                        cout << i << " " << j << " " << k << " " << l <<endl;
                }
            }
        }
    }*/
}


//wait darn

#include<bits/stdc++.h>

using namespace std;

#define ll long long
#define mp make_pair
#define pi pair<ll,ll>
#define x first
#define y second

int X,Y;

pi fix(pi a)
{
    a.x -= X;
    a.y -= Y;
    if(a.y < 0)
    {
        a.x *= -1;
        a.y *= -1;
    }

    return a;
}

bool eq(pi a, pi b)
{
    if(a.x*b.y == b.x*a.y)
    {
        return true;
    }
    return false;
}

bool comp(pi a, pi b)
{
    if(a.x == b.x && a.y == b.y)
        return true;

    if(a.y == 0 && b.y == 0)
    {
        if(a.x < b.x)
            return true;
        return false;
    }

    if(a.y == 0)
        return true;

    if(b.y == 0)
        return false;

    if(a.x*b.y < b.x*a.y)
        return true;
    if(a.x*b.y > b.x*a.y)
        return false;

    if(a.x < b.x)
        return true;
    if(a.x > b.x)
        return false;
    if(a.y < b.y)
        return true;
    return false;
}

int main()
{
    //ifstream fin ("test.in");
    //ofstream fout("test.out");

    //for(int i = 0; i < 2000;i++)
        //fin << 0 << " " << i << endl;

    int n;
    cin >> n;

    if(n < 3)
    {
        cout << 0;
        return 0;
    }

    pi point[n];
    pi stor[n-1];

    int i,j,k,l;

    for(i = 0; i < n;i++)
    {
        cin >> point[i].x >> point[i].y;
    }

    ll ans = n;
    ans = ans*(ans-1)*(ans-2);
    ans /= 6;

    ll asdf1, asdf2, asdf3 = 0;

    for(i = 0; i < n;i++)
    {
        X = point[i].x;
        Y = point[i].y;
        k = 0;
        for(j = 0; j < n;j++)
        {
            if(j != i)
            {
                stor[k] = fix(point[j]);
                k++;
            }
        }

        stable_sort(stor,stor+(k),comp);

        asdf1 = 0;
        asdf2 = 0;
        for(j = 1; j+1 < n;j++)
        {
            if(eq(stor[j],stor[j-1]))
            {
                asdf2++;
            }
            else
            {
                asdf2 = 0;
            }
            asdf1 += asdf2;
        }
        asdf3 += asdf1;
    }
    ans -= asdf3/3;
    cout << ans;

    /*for(int i = -5; i < 50;i++)
    {
        for(int j = 0; j < 50;j++)
        {
            for(int k = -5; k < 50;k++)
            {
                for(int l = 0; l < 50;l++)
                {
                    if(comp(mp(i,j),mp(k,l)) == comp(mp(k,l),mp(i,j)) && !eq(mp(i,j),mp(k,l)))
                        cout << i << " " << j << " " << k << " " << l <<endl;
                }
            }
        }
    }*/
}


//wait darn

#include<bits/stdc++.h>

using namespace std;

#define ll long long
#define mp make_pair
#define pi pair<int,int>
#define x first
#define y second

int X,Y;

pi fix(pi a)
{
    a.x -= X;
    a.y -= Y;
    if(a.y < 0)
    {
        a.x *= -1;
        a.y *= -1;
    }

    return a;
}

bool comp(pi a, pi b)
{
    if(a.y == 0)
        return true;

    if(b.y == 0)
        return false;

    if(a.x*b.y < b.x*a.y)
        return true;
    return false;
}

bool eq(pi a, pi b)
{
    if(a.x*b.y == b.x*a.y)
    {
        return true;
    }
    return false;
}

int main()
{
    int n;
    cin >> n;

    if(n < 3)
    {
        cout << 0;
        return 0;
    }

    pi point[n];
    pi stor[n-1];

    int i,j,k,l;

    for(i = 0; i < n;i++)
    {
        cin >> point[i].x >> point[i].y;
    }

    ll ans = n;
    ans = ans*(ans-1)*(ans-2);
    ans /= 6;

    ll asdf1, asdf2, asdf3 = 0;

    for(i = 0; i < n;i++)
    {
        X = point[i].x;
        Y = point[i].y;
        k = 0;
        for(j = 0; j < n;j++)
        {
            if(j != i)
            {
                stor[k] = fix(point[j]);
                k++;
            }
        }

        sort(stor,stor+(k),comp);

        asdf1 = 0;
        asdf2 = 1;
        for(j = 1; j+1 < n;j++)
        {
            if(eq(stor[j],stor[j-1]))
            {
                asdf2++;
            }
            else
            {
                asdf1 += asdf2*(asdf2-1);
                asdf2 = 1;
            }
        }
        asdf1 += asdf2*(asdf2-1);
        asdf3 += asdf1;
    }
    ans -= asdf3/6;
    cout << ans;
}


//wait darn

#include<bits/stdc++.h>

using namespace std;

#define ll long long
#define mp make_pair
#define pi pair<ll,ll>
#define x first
#define y second

int X,Y;

pi fix(pi a)
{
    a.x -= X;
    a.y -= Y;
    if(a.y < 0)
    {
        a.x *= -1;
        a.y *= -1;
    }

    return a;
}

bool eq(pi a, pi b)
{
    if(a.x*b.y == b.x*a.y)
    {
        return true;
    }
    return false;
}

bool comp(pi a, pi b)
{
    if(a.x == b.x && a.y == b.y)
        return true;

    if(a.y == 0 && b.y == 0)
    {
        if(a.x < b.x)
            return true;
        return false;
    }

    if(a.y == 0)
        return true;

    if(b.y == 0)
        return false;

    if(a.x*b.y < b.x*a.y)
        return true;
    if(a.x*b.y < b.x*a.y)
        return false;

    if(a.x < a.y)
        return true;
    return false;
}

int main()
{
    int n;
    cin >> n;

    if(n < 3)
    {
        cout << 0;
        return 0;
    }

    pi point[n];
    pi stor[n-1];

    int i,j,k,l;

    for(i = 0; i < n;i++)
    {
        cin >> point[i].x >> point[i].y;
    }

    ll ans = n;
    ans = ans*(ans-1)*(ans-2);
    ans /= 6;

    ll asdf1, asdf2, asdf3 = 0;

    for(i = 0; i < n;i++)
    {
        X = point[i].x;
        Y = point[i].y;
        k = 0;
        for(j = 0; j < n;j++)
        {
            if(j != i)
            {
                stor[k] = fix(point[j]);
                k++;
            }
        }

        sort(stor,stor+(k),comp);

        asdf1 = 0;
        asdf2 = 1;
        for(j = 1; j+1 < n;j++)
        {
            if(eq(stor[j],stor[j-1]))
            {
                asdf2++;
            }
            else
            {
                asdf1 += asdf2*(asdf2-1);
                asdf2 = 1;
            }
        }
        asdf1 += asdf2*(asdf2-1);
        asdf3 += asdf1;
    }
    ans -= asdf3/6;
    cout << ans;
}


//wait darn

#include<bits/stdc++.h>

using namespace std;

#define ll long long
#define mp make_pair
#define pi pair<ll,ll>
#define x first
#define y second

int X,Y;

pi fix(pi a)
{
    a.x -= X;
    a.y -= Y;
    if(a.y < 0)
    {
        a.x *= -1;
        a.y *= -1;
    }

    return a;
}

bool comp(pi a, pi b)
{

    if(a.y == 0 && b.y == 0)
    {
        if(a.x < b.x)
            return true;
        if(a.x > b.x)
            return false;
    }

    if(a.y == 0)
        return true;

    if(b.y == 0)
        return false;

    if(a.x*b.y < b.x*a.y)
        return true;
    if(a.x*b.y < b.x*a.y)
        return false;

    if(a.x < a.y)
        return true;
    return false;
}

bool eq(pi a, pi b)
{
    if(a.x*b.y == b.x*a.y)
    {
        return true;
    }
    return false;
}

int main()
{
    int n;
    cin >> n;

    if(n < 3)
    {
        cout << 0;
        return 0;
    }

    pi point[n];
    pi stor[n-1];

    int i,j,k,l;

    for(i = 0; i < n;i++)
    {
        cin >> point[i].x >> point[i].y;
    }

    ll ans = n;
    ans = ans*(ans-1)*(ans-2);
    ans /= 6;

    ll asdf1, asdf2, asdf3 = 0;

    for(i = 0; i < n;i++)
    {
        X = point[i].x;
        Y = point[i].y;
        k = 0;
        for(j = 0; j < n;j++)
        {
            if(j != i)
            {
                stor[k] = fix(point[j]);
                k++;
            }
        }

        sort(stor,stor+(k),comp);

        asdf1 = 0;
        asdf2 = 1;
        for(j = 1; j+1 < n;j++)
        {
            if(eq(stor[j],stor[j-1]))
            {
                asdf2++;
            }
            else
            {
                asdf1 += asdf2*(asdf2-1);
                asdf2 = 1;
            }
        }
        asdf1 += asdf2*(asdf2-1);
        asdf3 += asdf1;
    }
    ans -= asdf3/6;
    cout << ans;
}


//wait darn

#include<bits/stdc++.h>

using namespace std;

#define ll long long
#define mp make_pair
#define pi pair<ll,ll>
#define x first
#define y second

int X,Y;

pi fix(pi a)
{
    a.x -= X;
    a.y -= Y;
    if(a.y < 0)
    {
        a.x *= -1;
        a.y *= -1;
    }

    return a;
}

bool eq(pi a, pi b)
{
    if(a.x*b.y == b.x*a.y)
    {
        return true;
    }
    return false;
}

bool comp(pi a, pi b)
{
    if(a.x == b.x && a.y == b.y)
        return true;

    if(a.y == 0 && b.y == 0)
    {
        if(a.x < b.x)
            return true;
        return false;
    }

    if(a.y == 0)
        return true;

    if(b.y == 0)
        return false;

    if(a.x*b.y < b.x*a.y)
        return true;
    if(a.x*b.y > b.x*a.y)
        return false;

    if(a.x < b.x)
        return true;
    if(a.x > b.x)
        return false;
    if(a.y < b.y)
        return true;
    return false;
}

int main()
{
    //ifstream fin ("test.in");
    //ofstream fout("test.out");

    //for(int i = 0; i < 2000;i++)
        //fin << 0 << " " << i << endl;

    int n;
    cin >> n;

    if(n < 3)
    {
        cout << 0;
        return 0;
    }

    pi point[n];
    pi stor[n-1];

    int i,j,k,l;

    for(i = 0; i < n;i++)
    {
        cin >> point[i].x >> point[i].y;
    }

    ll ans = n;
    ans = ans*(ans-1)*(ans-2);
    ans /= 6;

    ll asdf1, asdf2, asdf3 = 0;

    for(i = 0; i < n;i++)
    {
        X = point[i].x;
        Y = point[i].y;
        k = 0;
        for(j = 0; j < n;j++)
        {
            if(j != i)
            {
                stor[k] = fix(point[j]);
                k++;
            }
        }

        sort(stor,stor+(k),comp);

        asdf1 = 1;
        asdf2 = 0;
        for(j = 1; j+1 < n;j++)
        {
            if(eq(stor[j],stor[j-1]))
            {
                asdf2++;
            }
            else
            {
                asdf2 = 0;
            }
            asdf1 += asdf2;
        }
        asdf3 += asdf1;
    }
    ans -= asdf3/6;
    cout << ans;

    /*for(int i = -5; i < 50;i++)
    {
        for(int j = 0; j < 50;j++)
        {
            for(int k = -5; k < 50;k++)
            {
                for(int l = 0; l < 50;l++)
                {
                    if(comp(mp(i,j),mp(k,l)) == comp(mp(k,l),mp(i,j)) && !eq(mp(i,j),mp(k,l)))
                        cout << i << " " << j << " " << k << " " << l <<endl;
                }
            }
        }
    }*/
}


//wait darn

#include<bits/stdc++.h>

using namespace std;

#define ll long long
#define mp make_pair
#define pi pair<ll,ll>
#define x first
#define y second

int X,Y;

pi fix(pi a)
{
    a.x -= X;
    a.y -= Y;
    if(a.y < 0)
    {
        a.x *= -1;
        a.y *= -1;
    }

    return a;
}

bool comp(pi a, pi b)
{
    if(a.y == 0)
        return true;

    if(b.y == 0)
        return false;

    if(a.x*b.y < b.x*a.y)
        return true;
    return false;
}

bool eq(pi a, pi b)
{
    if(a.x*b.y == b.x*a.y)
    {
        return true;
    }
    return false;
}

int main()
{
    int n;
    cin >> n;

    if(n < 3)
    {
        cout << 0;
        return 0;
    }

    pi point[n];
    pi stor[n-1];

    int i,j,k,l;

    for(i = 0; i < n;i++)
    {
        cin >> point[i].x >> point[i].y;
    }

    ll ans = n;
    ans = ans*(ans-1)*(ans-2);
    ans /= 6;

    ll asdf1, asdf2, asdf3 = 0;

    for(i = 0; i < n;i++)
    {
        X = point[i].x;
        Y = point[i].y;
        k = 0;
        for(j = 0; j < n;j++)
        {
            if(j != i)
            {
                stor[k] = fix(point[j]);
                k++;
            }
        }

        sort(stor,stor+(k),comp);

        asdf1 = 0;
        asdf2 = 1;
        for(j = 1; j+1 < n;j++)
        {
            if(eq(stor[j],stor[j-1]))
            {
                asdf2++;
            }
            else
            {
                asdf1 += asdf2*(asdf2-1);
                asdf2 = 1;
            }
        }
        asdf1 += asdf2*(asdf2-1);
        asdf3 += asdf1;
    }
    ans -= asdf3/6;
    cout << ans;
}


//wait darn

#include<bits/stdc++.h>

using namespace std;

#define ll long long
#define mp make_pair
#define pi pair<ll,ll>
#define x first
#define y second

int X,Y;

pi fix(pi a)
{
    a.x -= X;
    a.y -= Y;
    if(a.y < 0)
    {
        a.x *= -1;
        a.y *= -1;
    }

    return a;
}

bool eq(pi a, pi b)
{
    if(a.x*b.y == b.x*a.y)
    {
        return true;
    }
    return false;
}

bool comp(pi a, pi b)
{
    if(eq(a,b))
        return true;

    if(a.y == 0 && b.y == 0)
    {
        if(a.x < b.x)
            return true;
        if(a.x > b.x)
            return false;
    }

    if(a.y == 0)
        return true;

    if(b.y == 0)
        return false;

    if(a.x*b.y < b.x*a.y)
        return true;
    if(a.x*b.y < b.x*a.y)
        return false;

    if(a.x < a.y)
        return true;
    return false;
}

int main()
{
    int n;
    cin >> n;

    if(n < 3)
    {
        cout << 0;
        return 0;
    }

    pi point[n];
    pi stor[n-1];

    int i,j,k,l;

    for(i = 0; i < n;i++)
    {
        cin >> point[i].x >> point[i].y;
    }

    ll ans = n;
    ans = ans*(ans-1)*(ans-2);
    ans /= 6;

    ll asdf1, asdf2, asdf3 = 0;

    for(i = 0; i < n;i++)
    {
        X = point[i].x;
        Y = point[i].y;
        k = 0;
        for(j = 0; j < n;j++)
        {
            if(j != i)
            {
                stor[k] = fix(point[j]);
                k++;
            }
        }

        sort(stor,stor+(k),comp);

        asdf1 = 0;
        asdf2 = 1;
        for(j = 1; j+1 < n;j++)
        {
            if(eq(stor[j],stor[j-1]))
            {
                asdf2++;
            }
            else
            {
                asdf1 += asdf2*(asdf2-1);
                asdf2 = 1;
            }
        }
        asdf1 += asdf2*(asdf2-1);
        asdf3 += asdf1;
    }
    ans -= asdf3/6;
    cout << ans;
}


//wait darn

#include<bits/stdc++.h>

using namespace std;

#define ll long long
#define mp make_pair
#define pi pair<ll,ll>
#define x first
#define y second

int X,Y;

pi fix(pi a)
{
    a.x -= X;
    a.y -= Y;
    if(a.y < 0)
    {
        a.x *= -1;
        a.y *= -1;
    }

    return a;
}

bool eq(pi a, pi b)
{
    if(a.x*b.y == b.x*a.y)
    {
        return true;
    }
    return false;
}

bool comp(pi a, pi b)
{
    if(a.x == b.x && a.y == b.y)
        return true;

    if(a.y == 0 && b.y == 0)
    {
        if(a.x < b.x)
            return true;
        return false;
    }

    if(a.y == 0)
        return true;

    if(b.y == 0)
        return false;

    if(a.x*b.y < b.x*a.y)
        return true;
    if(a.x*b.y > b.x*a.y)
        return false;

    if(a.x < b.x)
        return true;
    if(a.x > b.x)
        return false;
    if(a.y < b.y)
        return true;
    return false;
}

int main()
{
    //ifstream fin ("test.in");
    //ofstream fout("test.out");

    //for(int i = 0; i < 2000;i++)
        //fin << 0 << " " << i << endl;

    int n;
    cin >> n;

    if(n < 3)
    {
        cout << 0;
        return 0;
    }

    pi point[n];
    pi stor[n-1];

    int i,j,k,l;

    for(i = 0; i < n;i++)
    {
        cin >> point[i].x >> point[i].y;
    }

    ll ans = n;
    ans = ans*(ans-1)*(ans-2);
    ans /= 6;

    ll asdf1, asdf2, asdf3 = 0;

    for(i = 0; i < n;i++)
    {
        X = point[i].x;
        Y = point[i].y;
        k = 0;
        for(j = 0; j < n;j++)
        {
            if(j != i)
            {
                stor[k] = fix(point[j]);
                k++;
            }
        }

        sort(stor,stor+(k),comp);

        asdf1 = 0;
        asdf2 = 0;
        for(j = 1; j+1 < n;j++)
        {
            if(eq(stor[j],stor[j-1]))
            {
                asdf2++;
            }
            else
            {
                asdf2 = 0;
            }
            asdf1 += asdf2;
        }
        asdf3 += asdf1;
    }
    ans -= asdf3/3;
    cout << ans;

    /*for(int i = -5; i < 50;i++)
    {
        for(int j = 0; j < 50;j++)
        {
            for(int k = -5; k < 50;k++)
            {
                for(int l = 0; l < 50;l++)
                {
                    if(comp(mp(i,j),mp(k,l)) == comp(mp(k,l),mp(i,j)) && !eq(mp(i,j),mp(k,l)))
                        cout << i << " " << j << " " << k << " " << l <<endl;
                }
            }
        }
    }*/
}


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

long long NCR(long long n , long long r)
{
    if(r > n) return 0;
    long long ans = 1;
    for(long long i = 0 ; i < min(r , n-r) ; i++)
        ans *= n-i , ans /= (i+1);
    return ans;
}

struct point
{
    double x , y;
    void getPoint()
    {
        cin >> x >> y;
    }
};

pair<double , double> getSlope(point p , point t)
{
    double xDif = p.x - t.x;
    double yDif = p.y - t.y;

    if(xDif == 0)
        return {1e9 , p.x};

    if(yDif == 0)
        return {-1e9 , p.y};

    return {yDif / xDif , p.y - ( yDif / xDif ) * p.x};
}

int BS(int target)
{
    int l = 0 , h = 1e4 , mid;
    while(l <= h)
    {
        mid = (l + h) / 2;
        int mul = mid * (mid+1) / 2;
        if(mul == target)
            return mid+1;
        else if(mul < target)
            l = mid+1;
        else h = mid-1;
    }
    return 0;
}

map<pair<double , double> , int> mp;

int main()
{
    ios::sync_with_stdio(0) , cin.tie(0) , cout.tie(0);

    int n;
    cin >> n;

    long long ans = NCR(n , 3);

    point p[n];
    for(int i = 0 ; i < n ; i++)
        p[i].getPoint();

    for(int i = 0 ; i < n ; i++)
        for(int j = i+1 ; j < n ; j++)
            mp[getSlope(p[i] , p[j])]++;

    for(auto i : mp)
        ans -= NCR(BS(i.second) , 3);

    cout << ans;

    return 0;
}


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

long long NCR(long long n , long long r)
{
    if(r > n) return 0;
    long long ans = 1;
    for(long long i = 0 ; i < min(r , n-r) ; i++)
        ans *= n-i , ans /= (i+1);
    return ans;
}

struct point
{
    double x , y;
    void getPoint()
    {
        cin >> x >> y;
    }
};

pair<double , double> getSlope(point p , point t)
{
    double xDif = p.x - t.x;
    double yDif = p.y - t.y;

    if(xDif == 0)
        return {5000 , p.x};

    return { (yDif / xDif) * 1e9 , (p.y - ( yDif / xDif ) * p.x) * 1e9 };
}

long long BS(long long target)
{
    long long l = 0 , h = 1e4 , mid;
    while(l <= h)
    {
        mid = (l + h) / 2;
        int mul = mid * (mid+1) / 2;
        if(mul == target)
            return mid+1;
        else if(mul < target)
            l = mid+1;
        else h = mid-1;
    }
    return 0;
}

map<pair<double , double> , long long> mp;

int main()
{
    ios::sync_with_stdio(0) , cin.tie(0) , cout.tie(0);

    int n;
    cin >> n;

    long long ans = NCR(n , 3);

    point p[n];
    for(int i = 0 ; i < n ; i++)
        p[i].getPoint();

    for(int i = 0 ; i < n ; i++)
        for(int j = i+1 ; j < n ; j++)
            mp[getSlope(p[i] , p[j])]++;

    for(auto i : mp)
        ans -= NCR(BS(i.second) , 3);

    cout << ans;

    return 0;
}


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

long long NCR(long long n , long long r)
{
    if(r > n) return 0;
    long long ans = 1;
    for(long long i = 0 ; i < min(r , n-r) ; i++)
        ans *= n-i , ans /= (i+1);
    return ans;
}

struct point
{
    double x , y;
    void getPoint()
    {
        cin >> x >> y;
    }
};

pair<double , double> getSlope(point p , point t)
{
    double xDif = p.x - t.x;
    double yDif = p.y - t.y;

    if(xDif == 0)
        return {1e9 , p.x};

    if(yDif == 0)
        return {-1e9 , p.y};

    return {yDif / xDif , p.y - ( yDif / xDif ) * p.x};
}

long long BS(long long target)
{
    long long l = 0 , h = 1e4 , mid;
    while(l <= h)
    {
        mid = (l + h) / 2;
        int mul = mid * (mid+1) / 2;
        if(mul == target)
            return mid+1;
        else if(mul < target)
            l = mid+1;
        else h = mid-1;
    }
    return 0;
}

map<pair<double , double> , long long> mp;

int main()
{
    ios::sync_with_stdio(0) , cin.tie(0) , cout.tie(0);

    int n;
    cin >> n;

    long long ans = NCR(n , 3);

    point p[n];
    for(int i = 0 ; i < n ; i++)
        p[i].getPoint();

    for(int i = 0 ; i < n ; i++)
        for(int j = i+1 ; j < n ; j++)
            mp[getSlope(p[i] , p[j])]++;

    for(auto i : mp)
        ans -= NCR(BS(i.second) , 3);

    cout << ans;

    return 0;
}


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

long long NCR(long long n , long long r)
{
    if(r > n) return 0;
    long long ans = 1;
    for(long long i = 0 ; i < min(r , n-r) ; i++)
        ans *= n-i , ans /= (i+1);
    return ans;
}

struct point
{
    double x , y;
    void getPoint()
    {
        cin >> x >> y;
    }
};

pair<double , double> getSlope(point p , point t)
{
    double xDif = p.x - t.x;
    double yDif = p.y - t.y;

    if(xDif == 0)
        return {5000 , p.x};

    return { (long long) ((yDif / xDif) * 1e14) , (long long) ((p.y - ( yDif / xDif ) * p.x) * 1e14) };
}

long long BS(long long target)
{
    long long l = 0 , h = 1e4 , mid;
    while(l <= h)
    {
        mid = (l + h) / 2;
        int mul = mid * (mid+1) / 2;
        if(mul == target)
            return mid+1;
        else if(mul < target)
            l = mid+1;
        else h = mid-1;
    }
    return 0;
}

map<pair<long long , long long> , long long> mp;

int main()
{
    ios::sync_with_stdio(0) , cin.tie(0) , cout.tie(0);

    int n;
    cin >> n;

    long long ans = NCR(n , 3);

    point p[n];
    for(int i = 0 ; i < n ; i++)
        p[i].getPoint();

    for(int i = 0 ; i < n ; i++)
        for(int j = i+1 ; j < n ; j++)
            mp[getSlope(p[i] , p[j])]++;

    for(auto i : mp)
        ans -= NCR(BS(i.second) , 3);

    cout << ans;

    return 0;
}


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

long long NCR(long long n , long long r)
{
    if(r > n) return 0;
    long long ans = 1;
    for(long long i = 0 ; i < min(r , n-r) ; i++)
        ans *= n-i , ans /= (i+1);
    return ans;
}

struct point
{
    double x , y;
    void getPoint()
    {
        cin >> x >> y;
    }
};

pair<double , double> getSlope(point p , point t)
{
    double xDif = p.x - t.x;
    double yDif = p.y - t.y;

    if(xDif == 0)
        return {5000 , p.x};

    return { (yDif / xDif) * 1e15 , (p.y - ( yDif / xDif ) * p.x) * 1e15 };
}

long long BS(long long target)
{
    long long l = 0 , h = 1e4 , mid;
    while(l <= h)
    {
        mid = (l + h) / 2;
        int mul = mid * (mid+1) / 2;
        if(mul == target)
            return mid+1;
        else if(mul < target)
            l = mid+1;
        else h = mid-1;
    }
    return 0;
}

map<pair<double , double> , long long> mp;

int main()
{
    ios::sync_with_stdio(0) , cin.tie(0) , cout.tie(0);

    int n;
    cin >> n;

    long long ans = NCR(n , 3);

    point p[n];
    for(int i = 0 ; i < n ; i++)
        p[i].getPoint();

    for(int i = 0 ; i < n ; i++)
        for(int j = i+1 ; j < n ; j++)
            mp[getSlope(p[i] , p[j])]++;

    for(auto i : mp)
        ans -= NCR(BS(i.second) , 3);

    cout << ans;

    return 0;
}


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

long long NCR(long long n , long long r)
{
    if(r > n) return 0;
    long long ans = 1;
    for(long long i = 0 ; i < min(r , n-r) ; i++)
        ans *= n-i , ans /= (i+1);
    return ans;
}

struct point
{
    double x , y;
    void getPoint()
    {
        cin >> x >> y;
    }
};

pair<double , double> getSlope(point p , point t)
{
    double xDif = p.x - t.x;
    double yDif = p.y - t.y;

    if(xDif == 0)
        return {1e9 , p.x};

    if(yDif == 0)
        return {-1e9 , p.y};

    return {yDif / xDif , p.y - ( yDif / xDif ) * p.x};
}

long long BS(long long target)
{
    long long l = 0 , h = 1e9 , mid;
    while(l <= h)
    {
        mid = (l + h) / 2;
        int mul = mid * (mid+1) / 2;
        if(mul == target)
            return mid+1;
        else if(mul < target)
            l = mid+1;
        else h = mid-1;
    }
    return 0;
}

map<pair<double , double> , long long> mp;

int main()
{
    ios::sync_with_stdio(0) , cin.tie(0) , cout.tie(0);

    int n;
    cin >> n;

    long long ans = NCR(n , 3);

    point p[n];
    for(int i = 0 ; i < n ; i++)
        p[i].getPoint();

    for(int i = 0 ; i < n ; i++)
        for(int j = i+1 ; j < n ; j++)
            mp[getSlope(p[i] , p[j])]++;

    for(auto i : mp)
        ans -= NCR(BS(i.second) , 3);

    cout << ans;

    return 0;
}


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

long long NCR(long long n , long long r)
{
    if(r > n) return 0;
    long long ans = 1;
    for(long long i = 0 ; i < min(r , n-r) ; i++)
        ans *= n-i , ans /= (i+1);
    return ans;
}

struct point
{
    long double x , y;
    void getPoint()
    {
        cin >> x >> y;
    }
};

pair<long double , long double> getSlope(point p , point t)
{
    long double xDif = p.x - t.x;
    long double yDif = p.y - t.y;

    if(xDif == 0)
        return {5000 , p.x};

    return { (long long) ((yDif / xDif) * 1e9) , (long long) ((p.y - ( yDif / xDif ) * p.x) * 1e9) };
}

long long BS(long long target)
{
    long long l = 0 , h = 1e4 , mid;
    while(l <= h)
    {
        mid = (l + h) / 2;
        int mul = mid * (mid+1) / 2;
        if(mul == target)
            return mid+1;
        else if(mul < target)
            l = mid+1;
        else h = mid-1;
    }
    return 0;
}

map<pair<long long , long long> , long long> mp;

int main()
{
    ios::sync_with_stdio(0) , cin.tie(0) , cout.tie(0);

    int n;
    cin >> n;

    long long ans = NCR(n , 3);

    point p[n];
    for(int i = 0 ; i < n ; i++)
        p[i].getPoint();

    for(int i = 0 ; i < n ; i++)
        for(int j = i+1 ; j < n ; j++)
            mp[getSlope(p[i] , p[j])]++;

    for(auto i : mp)
        ans -= NCR(BS(i.second) , 3);

    cout << ans;

    return 0;
}


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

long long NCR(long long n , long long r)
{
    if(r > n) return 0;
    long long ans = 1;
    for(long long i = 0 ; i < min(r , n-r) ; i++)
        ans *= n-i , ans /= (i+1);
    return ans;
}

struct point
{
    double x , y;
    void getPoint()
    {
        cin >> x >> y;
    }
};

pair<double , double> getSlope(point p , point t)
{
    double xDif = p.x - t.x;
    double yDif = p.y - t.y;

    if(xDif == 0)
        return {5000 , p.x};

    return { (long long) ((yDif / xDif) * 1e9) , (long long) ((p.y - ( yDif / xDif ) * p.x) * 1e9) };
}

long long BS(long long target)
{
    long long l = 0 , h = 1e4 , mid;
    while(l <= h)
    {
        mid = (l + h) / 2;
        int mul = mid * (mid+1) / 2;
        if(mul == target)
            return mid+1;
        else if(mul < target)
            l = mid+1;
        else h = mid-1;
    }
    return 0;
}

map<pair<long long , long long> , long long> mp;

int main()
{
    ios::sync_with_stdio(0) , cin.tie(0) , cout.tie(0);

    int n;
    cin >> n;

    long long ans = NCR(n , 3);

    point p[n];
    for(int i = 0 ; i < n ; i++)
        p[i].getPoint();

    for(int i = 0 ; i < n ; i++)
        for(int j = i+1 ; j < n ; j++)
            mp[getSlope(p[i] , p[j])]++;

    for(auto i : mp)
        ans -= NCR(BS(i.second) , 3);

    cout << ans;

    return 0;
}


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

long long NCR(long long n , long long r)
{
    if(r > n) return 0;
    long long ans = 1;
    for(long long i = 0 ; i < min(r , n-r) ; i++)
        ans *= n-i , ans /= (i+1);
    return ans;
}

struct point
{
    double x , y;
    void getPoint()
    {
        cin >> x >> y;
    }
};

pair<double , double> getSlope(point p , point t)
{
    double xDif = p.x - t.x;
    double yDif = p.y - t.y;

    if(xDif == 0)
        return {5000 , p.x};

    return { (long long) ((yDif / xDif) * 1e7) , (long long) ((p.y - ( yDif / xDif ) * p.x) * 1e7) };
}

long long BS(long long target)
{
    long long l = 0 , h = 1e4 , mid;
    while(l <= h)
    {
        mid = (l + h) / 2;
        int mul = mid * (mid+1) / 2;
        if(mul == target)
            return mid+1;
        else if(mul < target)
            l = mid+1;
        else h = mid-1;
    }
    return 0;
}

map<pair<long long , long long> , long long> mp;

int main()
{
    ios::sync_with_stdio(0) , cin.tie(0) , cout.tie(0);

    int n;
    cin >> n;

    long long ans = NCR(n , 3);

    point p[n];
    for(int i = 0 ; i < n ; i++)
        p[i].getPoint();

    for(int i = 0 ; i < n ; i++)
        for(int j = i+1 ; j < n ; j++)
            mp[getSlope(p[i] , p[j])]++;

    for(auto i : mp)
        ans -= NCR(BS(i.second) , 3);

    cout << ans;

    return 0;
}


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

long long NCR(long long n , long long r)
{
    if(r > n) return 0;
    long long ans = 1;
    for(long long i = 0 ; i < min(r , n-r) ; i++)
        ans *= n-i , ans /= (i+1);
    return ans;
}

struct point
{
    long double x , y;
    void getPoint()
    {
        cin >> x >> y;
    }
};

pair<long double , long double> getSlope(point p , point t)
{
    long double xDif = p.x - t.x;
    long double yDif = p.y - t.y;

    if(xDif == 0)
        return {5000 , p.x};

    return { (long long) ((yDif / xDif) * 1e14) , (long long) ((p.y - ( yDif / xDif ) * p.x) * 1e14) };
}

long long BS(long long target)
{
    long long l = 0 , h = 1e4 , mid;
    while(l <= h)
    {
        mid = (l + h) / 2;
        int mul = mid * (mid+1) / 2;
        if(mul == target)
            return mid+1;
        else if(mul < target)
            l = mid+1;
        else h = mid-1;
    }
    return 0;
}

map<pair<long long , long long> , long long> mp;

int main()
{
    ios::sync_with_stdio(0) , cin.tie(0) , cout.tie(0);

    int n;
    cin >> n;

    long long ans = NCR(n , 3);

    point p[n];
    for(int i = 0 ; i < n ; i++)
        p[i].getPoint();

    for(int i = 0 ; i < n ; i++)
        for(int j = i+1 ; j < n ; j++)
            mp[getSlope(p[i] , p[j])]++;

    for(auto i : mp)
        ans -= NCR(BS(i.second) , 3);

    cout << ans;

    return 0;
}


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

long long NCR(long long n , long long r)
{
    if(r > n) return 0;
    long long ans = 1;
    for(long long i = 0 ; i < min(r , n-r) ; i++)
        ans *= n-i , ans /= (i+1);
    return ans;
}

struct point
{
    long long x , y;
    void getPoint()
    {
        cin >> x >> y;
    }
};

pair<pair<long long , long long> , long long> getSlope(point p , point t)
{
    long long xDif = p.x - t.x;
    long long yDif = p.y - t.y;

    if(xDif == 0)
        return {{5000 , 5000} , p.x};

    long long g = __gcd(xDif , yDif);
    xDif /= g , yDif /= g;

    return {{xDif , yDif} , p.y * xDif - yDif * p.x};
}

long long BS(long long target)
{
    long long l = 0 , h = 1e4 , mid;
    while(l <= h)
    {
        mid = (l + h) / 2;
        int mul = mid * (mid+1) / 2;
        if(mul == target)
            return mid+1;
        else if(mul < target)
            l = mid+1;
        else h = mid-1;
    }
    return 0;
}

map<pair<pair<long long , long long> , long long> , long long> mp;

int main()
{
    ios::sync_with_stdio(0) , cin.tie(0) , cout.tie(0);

    int n;
    cin >> n;

    long long ans = NCR(n , 3);

    point p[n];
    for(int i = 0 ; i < n ; i++)
        p[i].getPoint();

    for(int i = 0 ; i < n ; i++)
        for(int j = i+1 ; j < n ; j++)
            mp[getSlope(p[i] , p[j])]++;

    for(auto i : mp)
        ans -= NCR(BS(i.second) , 3);

    cout << ans;

    return 0;
}


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

long long NCR(long long n , long long r)
{
    if(r > n) return 0;
    long long ans = 1;
    for(long long i = 0 ; i < min(r , n-r) ; i++)
        ans *= n-i , ans /= (i+1);
    return ans;
}

struct point
{
    long double x , y;
    void getPoint()
    {
        cin >> x >> y;
    }
};

pair<long double , long double> getSlope(point p , point t)
{
    long double xDif = p.x - t.x;
    long double yDif = p.y - t.y;

    if(xDif == 0)
        return {5000 , p.x};

    return {yDif / xDif , p.y - ( yDif / xDif ) * p.x};
}

long long BS(long long target)
{
    long long l = 0 , h = 1e4 , mid;
    while(l <= h)
    {
        mid = (l + h) / 2;
        int mul = mid * (mid+1) / 2;
        if(mul == target)
            return mid+1;
        else if(mul < target)
            l = mid+1;
        else h = mid-1;
    }
    return 0;
}

map<pair<long double , long double> , long long> mp;

int main()
{
    ios::sync_with_stdio(0) , cin.tie(0) , cout.tie(0);

    int n;
    cin >> n;

    long long ans = NCR(n , 3);

    point p[n];
    for(int i = 0 ; i < n ; i++)
        p[i].getPoint();

    for(int i = 0 ; i < n ; i++)
        for(int j = i+1 ; j < n ; j++)
            mp[getSlope(p[i] , p[j])]++;

    for(auto i : mp)
        ans -= NCR(BS(i.second) , 3);

    cout << ans;

    return 0;
}


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

long long NCR(long long n , long long r)
{
    if(r > n) return 0;
    long long ans = 1;
    for(long long i = 0 ; i < min(r , n-r) ; i++)
        ans *= n-i , ans /= (i+1);
    return ans;
}

struct point
{
    long double x , y;
    void getPoint()
    {
        cin >> x >> y;
    }
};

pair<long double , long double> getSlope(point p , point t)
{
    long double xDif = p.x - t.x;
    long double yDif = p.y - t.y;

    if(xDif == 0)
        return {1e9 , p.x};

    if(yDif == 0)
        return {-1e9 , p.y};

    return {yDif / xDif , p.y - ( yDif / xDif ) * p.x};
}

int BS(int target)
{
    int l = 0 , h = 1e4 , mid;
    while(l <= h)
    {
        mid = (l + h) / 2;
        int mul = mid * (mid+1) / 2;
        if(mul == target)
            return mid+1;
        else if(mul < target)
            l = mid+1;
        else h = mid-1;
    }
    return 0;
}

map<pair<long double , long double> , int> mp;

int main()
{
    ios::sync_with_stdio(0) , cin.tie(0) , cout.tie(0);

    int n;
    cin >> n;

    long long ans = NCR(n , 3);

    point p[n];
    for(int i = 0 ; i < n ; i++)
        p[i].getPoint();

    for(int i = 0 ; i < n ; i++)
        for(int j = i+1 ; j < n ; j++)
            mp[getSlope(p[i] , p[j])]++;

    for(auto i : mp)
        ans -= NCR(BS(i.second) , 3);

    cout << ans;

    return 0;
}


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

long long NCR(long long n , long long r)
{
    if(r > n) return 0;
    long long ans = 1;
    for(long long i = 0 ; i < min(r , n-r) ; i++)
        ans *= n-i , ans /= (i+1);
    return ans;
}

struct point
{
    double x , y;
    void getPoint()
    {
        cin >> x >> y;
    }
};

pair<double , double> getSlope(point p , point t)
{
    double xDif = p.x - t.x;
    double yDif = p.y - t.y;

    if(xDif == 0)
        return {5000 , p.x};

    return {yDif / xDif , p.y * xDif - yDif * p.x};
}

long long BS(long long target)
{
    long long l = 0 , h = 1e4 , mid;
    while(l <= h)
    {
        mid = (l + h) / 2;
        int mul = mid * (mid+1) / 2;
        if(mul == target)
            return mid+1;
        else if(mul < target)
            l = mid+1;
        else h = mid-1;
    }
    return 0;
}

map<pair<double , double> , long long> mp;

int main()
{
    ios::sync_with_stdio(0) , cin.tie(0) , cout.tie(0);

    int n;
    cin >> n;

    long long ans = NCR(n , 3);

    point p[n];
    for(int i = 0 ; i < n ; i++)
        p[i].getPoint();

    for(int i = 0 ; i < n ; i++)
        for(int j = i+1 ; j < n ; j++)
            mp[getSlope(p[i] , p[j])]++;

    for(auto i : mp)
        ans -= NCR(BS(i.second) , 3);

    cout << ans;

    return 0;
}


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

long long NCR(long long n , long long r)
{
    if(r > n) return 0;
    long long ans = 1;
    for(long long i = 0 ; i < min(r , n-r) ; i++)
        ans *= n-i , ans /= (i+1);
    return ans;
}

struct point
{
    double x , y;
    void getPoint()
    {
        cin >> x >> y;
    }
};

pair<double , double> getSlope(point p , point t)
{
    double xDif = p.x - t.x;
    double yDif = p.y - t.y;

    if(xDif == 0)
        return {5000 , p.x};

    return {yDif / xDif , p.y - ( yDif / xDif ) * p.x};
}

long long BS(long long target)
{
    long long l = 0 , h = 1e4 , mid;
    while(l <= h)
    {
        mid = (l + h) / 2;
        int mul = mid * (mid+1) / 2;
        if(mul == target)
            return mid+1;
        else if(mul < target)
            l = mid+1;
        else h = mid-1;
    }
    return 0;
}

map<pair<double , double> , long long> mp;

int main()
{
    ios::sync_with_stdio(0) , cin.tie(0) , cout.tie(0);

    int n;
    cin >> n;

    long long ans = NCR(n , 3);

    point p[n];
    for(int i = 0 ; i < n ; i++)
        p[i].getPoint();

    for(int i = 0 ; i < n ; i++)
        for(int j = i+1 ; j < n ; j++)
            mp[getSlope(p[i] , p[j])]++;

    for(auto i : mp)
        ans -= NCR(BS(i.second) , 3);

    cout << ans;

    return 0;
}


#include <iostream>
#include <math.h>
#include <algorithm>
#include <vector>
#include <map>

using namespace std;

typedef long long ll;

const int maxsize = 2000;
const int maxcoor = 200;

pair<int,int> p[maxsize+1];

bool coor[maxcoor+1][maxcoor+1],hori[maxcoor+1],vert[maxcoor+1];

map<pair<double,double>,bool> exist;

inline bool isPoint(double x,double y){
	return (x == (int)x && y == (int)y && coor[(int)x][(int)y]);
}

ll horizontal(int i,int j){
	ll result = 0;
	if(hori[p[i].first]) return result;
	hori[p[i].first] = true;
	for(int k=maxcoor;k>=0;--k){
		result += isPoint(p[i].first,k);
	}
	return result * (result - 1) * (result - 2) / 6;
}

ll vertical(int i,int j){
	ll result = 0;
	if(vert[p[i].second]) return result;
	vert[p[i].second] = true;
	for(int k=maxcoor;k>=0;--k){
		result += isPoint(k,p[i].second);
	}
	return result * (result - 1) * (result - 2) / 6;
}

ll getLine(int i,int j){
	long double x1 = p[i].first,y1 = p[i].second, x2 = p[j].first, y2 = p[j].second;
	long double a,b;
	if(x1 == x2) return horizontal(i,j);
	else if(y1 == y2) return vertical(i,j);
	else{
		a = (y1 - y2) / (x1 - x2);
		b = y1 - a * x1;
	}
	//cout<<"Case :"<<i<<" "<<j<<":"<<a<<" "<<b<<"\n";
	ll cnt = 0;
	if(exist[{a,b}]) return 0;
	exist[{a,b}] = true;

	long double tx = 0,ty = b;

	while(tx <= 200){
		if(0 <= ty && ty <= 200)
			cnt += (isPoint(tx,ty));
		tx++;
		ty += a;
	}

	return cnt * (cnt - 1) * (cnt - 2) / 6;
}

void solve(int n){
	ll result = (ll)n * (n - 1) * (n - 2) / 6;
	for(int i=1;i<=n;++i)
		for(int j=1;j<=n;++j)
			result -= getLine(i,j);

	cout<<result;
}

int main(){
	ios_base::sync_with_stdio(0);
	int n;
	cin>>n;
	for(int i=1;i<=n;++i){
		int x,y;
		cin>>x>>y;
		x += 100;
		y += 100;
		p[i] = {x,y};
		coor[x][y] = 1;
	}
	solve(n);
}


#include <iostream>
#include <cmath>
#include <algorithm>
#include <vector>
#include <cstring>
#include <deque>
#include <time.h>
#include <stack>
#include <stdio.h>
#include <map>
#include <set>
#include <string>
#include <fstream>
#include <queue>
#include <unordered_map>
#define mp make_pair
#define pb push_back
#define PI 3.14159265358979323846
#define MOD 1000000007
#define INF ((ll)1e+15)
#define x1 fldgjdflgjhrthrl
#define x2 fldgjdflgrtyrtyjl
#define y1 fldggfhfghjdflgjl
#define y2 ffgfldgjdflgjl
typedef long long ll;
using namespace std;
int i,j,n,m,x[3005],y[3005],a[4500000],b[20005][205];
unordered_map <ll, int> f;
unordered_map <ll, int>::iterator itr;
ll Abs(int a) {
	return a>0?a:-a;
}
ll gcd(int a, int b) {
	if (b == 0)
		return a;
	return gcd(b,a%b);
}
int main() {
	for (i = 1; i <= 20000; i++)
		for (j = 1; j <= 200; j++)
			b[i][j] = gcd(i,j);
	for (i = 1; i <= 20000; i++)
		b[i][0] = i;
	for (i = 1; i <= 200; i++)
		b[0][i] = i;
	cin >> n;
	for (i = 2; i <= 2000; i++)
		a[i*i-i] = i;
	for (i = 0; i < n; i++)
		cin >> x[i] >> y[i];
	for (i = 0; i < n; i++) {
		for (j = 0; j < n; j++)
			if (i != j) {
				int kc = y[j] - y[i];
				int kz = x[j] - x[i];
				int bc = y[i]*(x[j] - x[i]) - x[i]*(y[j]-y[i]);
				int bz = x[j] - x[i];
				if (kz != 0) {
					int tmp = b[Abs(kc)][Abs(kz)];
					kc /= tmp;
					kz /= tmp;
					if (kc < 0)
						kc = -kc, kz = -kz;
					if (kc == 0)
						kz = 1;
					tmp = b[Abs(bc)][Abs(bz)];
					bc /= tmp;
					bz /= tmp;
					if (bc < 0)
						bc = -bc, bz = -bz;
					if (bc == 0)
						bz = 1;
				} else
					kc = bc = x[i];
				ll hsh = bc*27000000000LL + bz*9000000LL + kc*300 + kz;
				f[hsh]+=2;
			}
	}
	ll ans = ((ll)n*(n-1)*(n-2))/6;
	for (itr = f.begin(); itr != f.end(); itr++) {
		int tmp = (*itr).second;
		tmp = a[tmp/2];
		ans -= ((ll)tmp*(tmp-1)*(tmp-2))/6;
	}
	cout << ans << endl;
	return 0;
}


#include <iostream>
#include <math.h>
#include <algorithm>
#include <vector>
#include <map>

using namespace std;

typedef long long ll;

const int maxsize = 2000;
const int maxcoor = 200;

pair<int,int> p[maxsize+1];

bool coor[maxcoor+1][maxcoor+1],hori[maxcoor+1],vert[maxcoor+1];

map<pair<double,double>,bool> exist;

inline bool isPoint(double x,double y){
	return (x == (int)x && y == (int)y && coor[(int)x][(int)y]);
}

inline bool relevant(double x,double y){
	return (0 <= x && x <= maxcoor && 0 <= y && y <= maxcoor);
}

ll horizontal(int i,int j){
	ll result = 0;
	if(hori[p[i].first]) return result;
	hori[p[i].first] = true;
	for(int k=maxcoor;k>=0;--k){
		result += isPoint(p[i].first,k);
	}
	return result * (result - 1) * (result - 2) / 6;
}

ll vertical(int i,int j){
	ll result = 0;
	if(vert[p[i].second]) return result;
	vert[p[i].second] = true;
	for(int k=maxcoor;k>=0;--k){
		result += isPoint(k,p[i].second);
	}
	return result * (result - 1) * (result - 2) / 6;
}

ll getLine(int i,int j){
	double x1 = p[i].first,y1 = p[i].second, x2 = p[j].first, y2 = p[j].second;
	double a,b;
	if(x1 == x2) return horizontal(i,j);
	else if(y1 == y2) return vertical(i,j);
	else{
		a = (double)(y1 - y2) / (x1 - x2);
		b = (double)y1 - a * x1;
	}
	//cout<<"Case :"<<i<<" "<<j<<":"<<a<<" "<<b<<"\n";
	ll cnt = 0;
	if(exist[{a,b}]) return 0;
	exist[{a,b}] = true;

	double tx = 0,ty = b;

	while(relevant(tx,0)){
		if(relevant(ty,0))
			cnt += (isPoint(tx,ty));
		tx++;
		ty = tx * a + b;
	}

	return cnt * (cnt - 1) * (cnt - 2) / 6;
}

void solve(int n){
	ll result = (ll)n * (n - 1) * (n - 2) / 6;
	sort(p+1,p+1+n);
	for(int i=1;i<n;++i)
		for(int j=i+1;j<=n;++j)
			result -= getLine(i,j);

	cout<<result;
}

int main(){
	ios_base::sync_with_stdio(0);
	int n;
	cin>>n;
	for(int i=1;i<=n;++i){
		int x,y;
		cin>>x>>y;
		x += 100;
		y += 100;
		p[i] = {x,y};
		coor[x][y] = 1;
	}
	solve(n);
}


#include <iostream>
#include <math.h>
#include <algorithm>
#include <vector>
#include <map>

using namespace std;

typedef long long ll;

const int maxsize = 2000;
const int maxcoor = 200;

pair<int,int> p[maxsize+1];

bool coor[maxcoor+1][maxcoor+1];

map<pair<double,double>,bool> exist;

inline bool isPoint(double x,double y){
	return (x == (int)x && y == (int)y && coor[(int)x][(int)y]);
}

inline bool relevant(double x,double y){
	return (0 <= x && x <= maxcoor && 0 <= y && y <= maxcoor);
}

ll getLine(int i,int j){
	int x1 = p[i].first,y1 = p[i].second, x2 = p[j].first, y2 = p[j].second;
	double a = -101 ,b = -101;
	if(x1 == x2) { a = 0; b = x1; }
	else if(y1 == y2) { a = y1; b = 0; }
	else{
		a = (double)(y1 - y2) / (x1 - x2);
		b = (double)y1 - a * x1;
	}
	ll cnt = 0;
	if(exist[{a,b}]) return 0;
	exist[{a,b}] = true;

	double tx = 0,ty = b;

	while(relevant(tx,ty)){
		cnt += (isPoint(tx,ty));
		tx++;
		ty = tx * a + b;
	}

	tx = -1,ty = -a + b;

	while(relevant(tx,ty)){
		cnt += (isPoint(tx,ty));
		tx--;
		ty = tx * a + b;
	}

	return cnt * (cnt - 1) * (cnt - 2) / 6;
}

void solve(int n){
	ll result = (ll)n * (n - 1) * (n - 2) / 6;

	for(int i=1;i<n;++i)
		for(int j=i+1;j<=n;++j)
			result -= getLine(i,j);

	cout<<result;
}

int main(){
	int n;
	cin>>n;
	for(int i=1;i<=n;++i){
		int x,y;
		cin>>x>>y;
		x += 100;
		y += 100;
		p[i] = {x,y};
		coor[x][y] = 1;
	}
	solve(n);
}


#include <iostream>
#include <math.h>
#include <algorithm>
#include <vector>
#include <map>

using namespace std;

typedef long long ll;

const int maxsize = 2000;
const int maxcoor = 200;

pair<int,int> p[maxsize+1];

bool coor[maxcoor+1][maxcoor+1],hori[maxcoor+1],vert[maxcoor+1];

map<pair<double,double>,bool> exist;

inline bool isPoint(double x,double y){
	return (x == (int)x && y == (int)y && coor[(int)x][(int)y]);
}

inline bool relevant(double x,double y){
	return (0 <= x && x <= maxcoor && 0 <= y && y <= maxcoor);
}

ll horizontal(int i,int j){
	ll result = 0;
	if(hori[p[i].first]) return result;
	hori[p[i].first] = true;
	for(int k=maxcoor;k>=0;--k){
		result += isPoint(p[i].first,k);
	}
	return result * (result - 1) * (result - 2) / 6;
}

ll vertical(int i,int j){
	ll result = 0;
	if(vert[p[i].second]) return result;
	vert[p[i].second] = true;
	for(int k=maxcoor;k>=0;--k){
		result += isPoint(k,p[i].second);
	}
	return result * (result - 1) * (result - 2) / 6;
}

ll getLine(int i,int j){
	double x1 = p[i].first,y1 = p[i].second, x2 = p[j].first, y2 = p[j].second;
	double a,b;
	if(x1 == x2) return horizontal(i,j);
	else if(y1 == y2) return vertical(i,j);
	else{
		a = (double)(y1 - y2) / (x1 - x2);
		b = (double)y1 - a * x1;
	}
	//cout<<"Case :"<<i<<" "<<j<<":"<<a<<" "<<b<<"\n";
	ll cnt = 0;
	if(exist[{a,b}]) return 0;
	exist[{a,b}] = true;

	double tx = 0,ty = b;

	while(relevant(tx,0)){
		if(relevant(ty,0))
			cnt += (isPoint(tx,ty));
		tx++;
		ty = tx * a + b;
	}

	tx = -1,ty = -a + b;

	while(relevant(tx,0)){
		if(relevant(ty,0))
			cnt += (isPoint(tx,ty));
		tx--;
		ty = tx * a + b;
	}

	return cnt * (cnt - 1) * (cnt - 2) / 6;
}

void solve(int n){
	ll result = (ll)n * (n - 1) * (n - 2) / 6;

	for(int i=1;i<n;++i)
		for(int j=i+1;j<=n;++j)
			result -= getLine(i,j);

	cout<<result;
}

int main(){
	ios_base::sync_with_stdio(0);
	int n;
	cin>>n;
	for(int i=1;i<=n;++i){
		int x,y;
		cin>>x>>y;
		x += 100;
		y += 100;
		p[i] = {x,y};
		coor[x][y] = 1;
	}
	solve(n);
}


#include <iostream>
#include <math.h>
#include <algorithm>
#include <vector>
#include <map>

using namespace std;

typedef long long ll;

const int maxsize = 2000;
const int maxcoor = 200;

pair<int,int> p[maxsize+1];

bool coor[maxcoor+1][maxcoor+1],hori[maxcoor+1],vert[maxcoor+1];

map<pair<double,double>,bool> exist;

inline bool isPoint(double x,double y){
	return (x == (int)x && y == (int)y && coor[(int)x][(int)y]);
}

inline bool relevant(double x,double y){
	return (0 <= x && x <= maxcoor && 0 <= y && y <= maxcoor);
}

ll horizontal(int i,int j){
	ll result = 0;
	hori[p[i].first] = true;
	for(int k=maxcoor;k>=0;--k){
		result += isPoint(p[i].first,k);
	}
	return result * (result - 1) * (result - 2) / 6;
}

ll vertical(int i,int j){
	ll result = 0;
	vert[p[i].second] = true;
	for(int k=maxcoor;k>=0;--k){
		result += isPoint(k,p[i].second);
	}
	return result * (result - 1) * (result - 2) / 6;
}

ll getLine(int i,int j){
	double x1 = p[i].first,y1 = p[i].second, x2 = p[j].first, y2 = p[j].second;
	double a,b;
	if(x1 == x2 && !hori[(int)x1]) return horizontal(i,j);
	else if(y1 == y2 && !vert[(int)y1]) return vertical(i,j);
	else{
		a = (double)(y1 - y2) / (x1 - x2);
		b = (double)y1 - a * x1;
	}
	//cout<<"Case :"<<i<<" "<<j<<":"<<a<<" "<<b<<"\n";
	ll cnt = 0;
	if(exist[{a,b}]) return 0;
	exist[{a,b}] = true;

	double tx = 0,ty = b;

	while(relevant(tx,0)){
		if(relevant(ty,0))
			cnt += (isPoint(tx,ty));
		tx++;
		ty = tx * a + b;
	}

	tx = -1,ty = -a + b;

	while(relevant(tx,0)){
		if(relevant(ty,0))
			cnt += (isPoint(tx,ty));
		tx--;
		ty = tx * a + b;
	}

	return cnt * (cnt - 1) * (cnt - 2) / 6;
}

void solve(int n){
	ll result = (ll)n * (n - 1) * (n - 2) / 6;

	for(int i=1;i<n;++i)
		for(int j=i+1;j<=n;++j)
			result -= getLine(i,j);

	cout<<result;
}

int main(){
	ios_base::sync_with_stdio(0);
	int n;
	cin>>n;
	for(int i=1;i<=n;++i){
		int x,y;
		cin>>x>>y;
		x += 100;
		y += 100;
		p[i] = {x,y};
		coor[x][y] = 1;
	}
	solve(n);
}


#include <iostream>
#include <math.h>
#include <algorithm>
#include <vector>
#include <map>

using namespace std;

typedef long long ll;

const int maxsize = 2000;
const int maxcoor = 200;

pair<int,int> p[maxsize+1];

bool coor[maxcoor+1][maxcoor+1],hori[maxcoor+1],vert[maxcoor+1];

map<pair<long double,long double>,bool> exist;

inline bool isPoint(long double x,long double y){
	return (x == (int)x && y == (int)y && coor[(int)x][(int)y]);
}

ll horizontal(int i,int j){
	ll result = 0;
	if(hori[p[i].first]) return result;
	hori[p[i].first] = true;
	for(int k=maxcoor;k>=0;--k){
		result += isPoint(p[i].first,k);
	}
	return result * (result - 1) * (result - 2) / 6;
}

ll vertical(int i,int j){
	ll result = 0;
	if(vert[p[i].second]) return result;
	vert[p[i].second] = true;
	for(int k=maxcoor;k>=0;--k){
		result += isPoint(k,p[i].second);
	}
	return result * (result - 1) * (result - 2) / 6;
}

ll getLine(int i,int j){
	long double x1 = p[i].first,y1 = p[i].second, x2 = p[j].first, y2 = p[j].second;
	long double a,b;
	if(x1 == x2) return horizontal(i,j);
	else if(y1 == y2) return vertical(i,j);
	else{
		a = (y1 - y2) / (x1 - x2);
		b = y1 - a * x1;
	}
	//cout<<"Case :"<<i<<" "<<j<<":"<<a<<" "<<b<<"\n";
	ll cnt = 0;
	if(exist[{a,b}]) return 0;
	exist[{a,b}] = true;

	long double tx = 0,ty = b;

	while(tx <= 200){
		if(0 <= ty && ty <= 200)
			cnt += (isPoint(tx,ty));
		tx++;
		ty += a;
	}

	return cnt * (cnt - 1) * (cnt - 2) / 6;
}

void solve(int n){
	ll result = (ll)n * (n - 1) * (n - 2) / 6;
	for(int i=1;i<=n;++i)
		for(int j=1;j<=n;++j)
			result -= getLine(i,j);

	cout<<result;
}

int main(){
	ios_base::sync_with_stdio(0);
	int n;
	cin>>n;
	for(int i=1;i<=n;++i){
		int x,y;
		cin>>x>>y;
		x += 100;
		y += 100;
		p[i] = {x,y};
		coor[x][y] = 1;
	}
	solve(n);
}


#include <iostream>
#include <math.h>
#include <algorithm>
#include <vector>
#include <map>

using namespace std;

typedef long long ll;

const int maxsize = 2000;
const int maxcoor = 200;

pair<int,int> p[maxsize+1];

bool coor[maxcoor+1][maxcoor+1];

map<pair<double,double>,bool> exist;

inline bool isPoint(double x,double y){
	return (x == (int)x && y == (int)y && coor[(int)x][(int)y]);
}

inline bool relevant(double x,double y){
	return (0 <= x && x <= maxcoor && 0 <= y && y <= maxcoor);
}

ll getLine(int i,int j){
	double x1 = p[i].first,y1 = p[i].second, x2 = p[j].first, y2 = p[j].second;
	double a,b;
	if(x1 == x2) { a = 0; b = x1; }
	else if(y1 == y2) { a = y1; b = 0; }
	else{
		a = (double)(y1 - y2) / (x1 - x2);
		b = (double)y1 - a * x1;
	}
	//cout<<"Case :"<<i<<" "<<j<<":"<<a<<" "<<b<<"\n";
	ll cnt = 0;
	if(exist[{a,b}]) return 0;
	exist[{a,b}] = true;

	double tx = 0,ty = b;

	while(relevant(tx,0)){
		cnt += (isPoint(tx,ty) && relevant(ty,0));
		tx++;
		ty = tx * a + b;
	}

	tx = -1,ty = -a + b;

	while(relevant(tx,0)){
		cnt += (isPoint(tx,ty) && relevant(ty,0));
		tx--;
		ty = tx * a + b;
	}

	return cnt * (cnt - 1) * (cnt - 2) / 6;
}

void solve(int n){
	ll result = (ll)n * (n - 1) * (n - 2) / 6;

	for(int i=1;i<n;++i)
		for(int j=i+1;j<=n;++j)
			result -= getLine(i,j);

	cout<<result;
}

int main(){
	ios_base::sync_with_stdio(0);
	int n;
	cin>>n;
	for(int i=1;i<=n;++i){
		int x,y;
		cin>>x>>y;
		x += 100;
		y += 100;
		p[i] = {x,y};
		coor[x][y] = 1;
	}
	solve(n);
}


#include <iostream>
#include <math.h>
#include <algorithm>
#include <vector>
#include <map>

using namespace std;

typedef long long ll;

const int maxsize = 2000;
const int maxcoor = 200;

pair<int,int> p[maxsize+1];

bool coor[maxcoor+1][maxcoor+1];

map<pair<double,double>,bool> exist;

inline bool isPoint(double x,double y){
	return (x == (int)x && y == (int)y && coor[(int)x][(int)y]);
}

inline bool relevant(double x,double y){
	return (0 <= x && x <= maxcoor && 0 <= y && y <= maxcoor);
}

ll getLine(int i,int j){
	double x1 = p[i].first,y1 = p[i].second, x2 = p[j].first, y2 = p[j].second;
	double a,b;
	if(x1 == x2) { a = 0; b = x1; }
	else if(y1 == y2) { a = y1; b = 0; }
	else{
		a = (double)(y1 - y2) / (x1 - x2);
		b = (double)y1 - a * x1;
	}
	//cout<<"Case :"<<i<<" "<<j<<":"<<a<<" "<<b<<"\n";
	ll cnt = 0;
	if(exist[{a,b}]) return 0;
	exist[{a,b}] = true;

	double tx = 0,ty = b;

	while(relevant(tx,0)){
		if(relevant(ty,0))
			cnt += (isPoint(tx,ty));
		tx++;
		ty = tx * a + b;
	}

	tx = -1,ty = -a + b;

	while(relevant(tx,0)){
		if(relevant(ty,0))
			cnt += (isPoint(tx,ty));
		tx--;
		ty = tx * a + b;
	}

	return cnt * (cnt - 1) * (cnt - 2) / 6;
}

void solve(int n){
	ll result = (ll)n * (n - 1) * (n - 2) / 6;

	for(int i=1;i<n;++i)
		for(int j=i+1;j<=n;++j)
			result -= getLine(i,j);

	cout<<result;
}

int main(){
	ios_base::sync_with_stdio(0);
	int n;
	cin>>n;
	for(int i=1;i<=n;++i){
		int x,y;
		cin>>x>>y;
		x += 100;
		y += 100;
		p[i] = {x,y};
		coor[x][y] = 1;
	}
	solve(n);
}


	#include<bits/stdc++.h>
	#define ll long long
	#define clear(x) memset(x,0,sizeof(x))
	#define pb push_back
	#define ff first
	#define ss second
	using namespace std;
	const ll mod=1e9+7;
	const ll size=2007;
	ll x[size];
	ll y[size];
	int main()
	{
		ios_base::sync_with_stdio(false);
		int n;
		cin>>n;
		for(int i=0;i<n;i++)
			cin>>x[i]>>y[i];
		int c=0;
		for(int i=0;i<n;i++)
			for(int j=i+1;j<n;j++)
				for(int k=j+1;k<n;k++)
					if(x[i]*(y[j]-y[k])+x[j]*(y[k]-y[i])+x[k]*(y[i]-y[j])!=0)c++;
		cout<<c<<endl;
	}


	#include<iostream>
	using namespace std;
	const int size=2007;
	int x[size];
	int y[size];
	int main()
	{
		ios_base::sync_with_stdio(false);
		int n,i,j,k;
		cin>>n;
		for(i=0;i<n;i++)
			cin>>x[i]>>y[i];
		int c=0;
		for(i=0;i<n;i++)
			for(j=i+1;j<n;j++)
				for(k=j+1;k<n;k++)
					if(x[i]*(y[j]-y[k])+x[j]*(y[k]-y[i])+x[k]*(y[i]-y[j])!=0)c++;
		cout<<c<<endl;
	}


#include<iostream>
	using namespace std;
	const int size=2007;
	int x[size];
	int y[size];
	int main()
	{
		ios_base::sync_with_stdio(false);
		int n,i,j,k;
		cin>>n;
		for(i=0;i<n;i++)
			cin>>x[i]>>y[i];
		int c=0;
		for(i=0;i<n;i++)
			for(j=i+1;j<n;j++)
				for(k=j+1;k<n;k++)
					if(x[i]*(y[j]-y[k])+x[j]*(y[k]-y[i])+x[k]*(y[i]-y[j])!=0)c++;
		cout<<c<<endl;
	}


	#include<iostream>
	const ll mod=1e9+7;
	const ll size=2007;
	ll x[size];
	ll y[size];
	int main()
	{
		ios_base::sync_with_stdio(false);
		int n,i,j,k;
		cin>>n;
		for(i=0;i<n;i++)
			cin>>x[i]>>y[i];
		int c=0;
		for(i=0;i<n;i++)
			for(j=i+1;j<n;j++)
				for(k=j+1;k<n;k++)
					if(x[i]*(y[j]-y[k])+x[j]*(y[k]-y[i])+x[k]*(y[i]-y[j])!=0)c++;
		cout<<c<<endl;
	}


#include<bits/stdc++.h>
#define ll long long
#define clear(x) memset(x,0,sizeof(x))
#define pb push_back
#define ff first
#define ss second
using namespace std;
const ll mod=1e9+7;
const ll size=1e2+7;
ll arr[size][size];
bool collinear(ll x1, ll y1, ll x2, ll y2, ll x3, ll y3) {
  return (y1 - y2) * (x1 - x3) == (y1 - y3) * (x1 - x2);
}
ll nC3(ll n)
{
	if(n<3)
		return 0;
	return (n*(n-1)*(n-2))/6;
}
int main()
{
	ll n;
	cin>>n;
	vector< pair<ll,ll> > vi;
	map< pair<ll,ll> , ll > mp;
	for(ll i=0;i<n;i++)
	{
		ll x,y;
		cin>>x>>y;
		vi.pb(make_pair(x,y));
		mp[vi[i]]=0;
	}
	ll m=0;
	ll ans=0;
	for(ll i=0;i<n;i++)
	{
		for(ll j=i+1;j<n;j++)
		{
			ll c=0;
			vector <ll> temp;
			for(ll k=0;k<n;k++)
			{
				if(k==i||k==j)continue;
				if(collinear(vi[i].ff,vi[i].ss,vi[j].ff,vi[j].ss,vi[k].ff,vi[k].ss)&&mp[vi[i]]==0&&mp[vi[j]]==0&&mp[vi[k]]==0)
					c++,mp[vi[k]]=1,temp.pb(k);
			}
			for(ll x=0;x<temp.size();x++)mp[vi[temp[x]]]=0;
			//cout<<c<<endl;
			ans=ans+nC3(c+2);
			mp[vi[j]]=1;
		}
		for(ll x=i+1;x<n;x++)mp[vi[x]]=0;
		mp[vi[i]]=1;
	}
	ans=nC3(n)-ans;
	cout<<ans<<endl;
}


	#include<bits/stdc++.h>
	#define ll long long
	#define clear(x) memset(x,0,sizeof(x))
	#define pb push_back
	#define ff first
	#define ss second
	using namespace std;
	const ll mod=1e9+7;
	const ll size=2007;
	ll x[size];
	ll y[size];
	int main()
	{
		int n;
		cin>>n;
		for(int i=0;i<n;i++)
			cin>>x[i]>>y[i];
		ll c=0;
		for(int i=0;i<n;i++)
			for(int j=i+1;j<n;j++)
				for(int k=j+1;k<n;k++)
					if(x[i]*(y[j]-y[k])+x[j]*(y[k]-y[i])+x[k]*(y[i]-y[j])!=0)c++;
		cout<<c<<endl;
	}


	#include<bits/stdc++.h>
	#define ll long long
	#define clear(x) memset(x,0,sizeof(x))
	#define pb push_back
	#define ff first
	#define ss second
	using namespace std;
	const ll mod=1e9+7;
	const ll size=1e3+7;
	ll x[size];
	ll y[size];
	int main()
	{
		int n;
		cin>>n;
		for(int i=0;i<n;i++)
			cin>>x[i]>>y[i];
		ll c=0;
		for(int i=0;i<n;i++)
			for(int j=i+1;j<n;j++)
				for(int k=j+1;k<n;k++)
					if(x[i]*(y[j]-y[k])+x[j]*(y[k]-y[i])+x[k]*(y[i]-y[j])!=0)c++;
		cout<<c<<endl;
	}


	#include<iostream>
	using namespace std;
	const ll mod=1e9+7;
	const ll size=2007;
	ll x[size];
	ll y[size];
	int main()
	{
		ios_base::sync_with_stdio(false);
		int n,i,j,k;
		cin>>n;
		for(int i=0;i<n;i++)
			cin>>x[i]>>y[i];
		int c=0;
		for(i=0;i<n;i++)
			for(j=i+1;j<n;j++)
				for(k=j+1;k<n;k++)
					if(x[i]*(y[j]-y[k])+x[j]*(y[k]-y[i])+x[k]*(y[i]-y[j])!=0)c++;
		cout<<c<<endl;
	}


	#include<iostream>
	const int size=2007;
	int x[size];
	int y[size];
	int main()
	{
		ios_base::sync_with_stdio(false);
		int n,i,j,k;
		cin>>n;
		for(i=0;i<n;i++)
			cin>>x[i]>>y[i];
		int c=0;
		for(i=0;i<n;i++)
			for(j=i+1;j<n;j++)
				for(k=j+1;k<n;k++)
					if(x[i]*(y[j]-y[k])+x[j]*(y[k]-y[i])+x[k]*(y[i]-y[j])!=0)c++;
		cout<<c<<endl;
	}


#include<bits/stdc++.h>
#define ll long long
#define clear(x) memset(x,0,sizeof(x))
#define pb push_back
#define ff first
#define ss second
using namespace std;
const ll mod=1e9+7;
const ll size=1e2+7;
ll arr[size][size];
bool collinear(ll x1, ll y1, ll x2, ll y2, ll x3, ll y3) {
  return (y1 - y2) * (x1 - x3) == (y1 - y3) * (x1 - x2);
}
ll nC3(ll n)
{
	if(n<3)
		return 0;
	return (n*(n-1)*(n-2))/6;
}
int main()
{
	ll n;
	cin>>n;
	vector< pair<ll,ll> > vi;
	map< pair<ll,ll> , ll > mp;
	for(ll i=0;i<n;i++)
	{
		ll x,y;
		cin>>x>>y;
		vi.pb(make_pair(x,y));
		mp[vi[i]]=0;
	}
	ll m=0;
	ll ans=0;
	vector <ll> temp;
	for(ll i=0;i<n;i++)
	{
		for(ll j=i+1;j<n;j++)
		{
			ll c=0;
			for(ll k=0;k<n;k++)
			{
				if(k==i||k==j)continue;
				if(collinear(vi[i].ff,vi[i].ss,vi[j].ff,vi[j].ss,vi[k].ff,vi[k].ss)&&mp[vi[i]]==0&&mp[vi[j]]==0&&mp[vi[k]]==0)
					c++,mp[vi[k]]=1,temp.pb(k);
			}
			for(ll x=0;x<temp.size();x++)mp[vi[temp[x]]]=0;
			//cout<<c<<endl;
			ans=ans+nC3(c+2);
			mp[vi[j]]=1;
		}
		for(ll x=i+1;x<n;x++)mp[vi[x]]=0;
		mp[vi[i]]=1;
	}
	ans=nC3(n)-ans;
	cout<<ans<<endl;
}


#include <bits/stdc++.h>

using namespace std;

#define rfile freopen("parties.in", "r", stdin)
#define wfile freopen("parties.out", "w", stdout)
#define files rfile; wfile
#define pb push_back

typedef long long ll;
typedef long double ld;
typedef vector< int > vi;
typedef vector< char > vc;
typedef vector< vc > vvc;
typedef vector< vi > vvi;
typedef map< int, int > mapT;
typedef pair< int, int > pairT;

const int inf = (int)1e9;
const int N = (int)211;

char is[N][N];

int main()
{
	int n, x, y, ans = 0;
	scanf("%d", &n);
	vector< pairT > pos(n);
	for (int i = 0; i < n; i++)
	{
		scanf("%d %d", &pos[i].first, &pos[i].second);
		is[pos[i].first + 100][pos[i].second + 100] = 1;
	}
	sort(pos.begin(), pos.end());
	for (int i = 0; i < n - 2; i++)
		for (int j = i + 1; j < n - 1; j++)
		{
			int cnt = 0, x1 = pos[i].first, y1 = pos[i].second, x2 = pos[j].first, y2 = pos[j].second,
				a = x1 - x2, b = y2 - y1, c = -a * y1 - b * x1, y;
			if (a == 0)
			{
				for (y = -100; y <= 100; y++)
					if (is[x1 + 100][y] == 1)
						cnt++;
			}
			else
				for (int x = x2 + 1; x <= 100; x++)
					if (x != x1 && x != x2 && abs(b * x + c) % abs(a) == 0)
						if (is[x + 100][(b * x + c) / (-a) + 100] == 1)
							cnt++;
			ans += n - (j + 1) - cnt;
		}
	printf("%d", ans);
	return 0;
}


#include <bits/stdc++.h>

using namespace std;

#define rfile freopen("parties.in", "r", stdin)
#define wfile freopen("parties.out", "w", stdout)
#define files rfile; wfile
#define pb push_back

typedef long long ll;
typedef long double ld;
typedef vector< int > vi;
typedef vector< char > vc;
typedef vector< vc > vvc;
typedef vector< vi > vvi;
typedef map< int, int > mapT;
typedef pair< int, int > pairT;

const int inf = (int)1e9;
const int N = (int)211;

char is[N][N];

bool comp(pairT a, pairT b)
{
	if (a.first == b.first)
		return a.second < b.second;
	else
		return a.first < b.first;
}

int main()
{
	int n, x, y, ans = 0;
	scanf("%d", &n);
	vector< pairT > pos(n);
	for (int i = 0; i < n; i++)
	{
		scanf("%d %d", &pos[i].first, &pos[i].second);
		is[pos[i].first + 100][pos[i].second + 100] = 1;
	}
	sort(pos.begin(), pos.end(), comp);
	for (int i = 0; i < n - 2; i++)
		for (int j = i + 1; j < n - 1; j++)
		{
			int cnt = 0, x1 = pos[i].first, y1 = pos[i].second, x2 = pos[j].first, y2 = pos[j].second,
				a = x1 - x2, b = y2 - y1, c = -a * y1 - b * x1, y;
			if (a == 0)
			{
				for (y = y2 + 1; y <= 100; y++)
					if (is[x1 + 100][y + 100] == 1)
						cnt++;
			}
			else
				for (int x = x2 + 1; x <= 100; x++)
					if (x != x1 && x != x2 && abs(b * x + c) % abs(a) == 0)
						if (is[x + 100][(b * x + c) / (-a) + 100] == 1)
							cnt++;
			ans += n - (j + 1) - cnt;
		}
	printf("%d", ans);
	return 0;
}


#include <bits/stdc++.h>

using namespace std;

#define rfile freopen("parties.in", "r", stdin)
#define wfile freopen("parties.out", "w", stdout)
#define files rfile; wfile
#define pb push_back

typedef long long ll;
typedef long double ld;
typedef vector< int > vi;
typedef vector< char > vc;
typedef vector< vc > vvc;
typedef vector< vi > vvi;
typedef map< int, int > mapT;
typedef pair< int, int > pairT;

const int inf = (int)1e9;
const int N = (int)211;

char is[N][N];

bool comp(pairT a, pairT b)
{
	if (a.first == b.first)
		return a.second < b.second;
	else
		return a.first < b.first;
}

int main()
{
	ll ans = (ll)0;
	int n, x, y;
	scanf("%d", &n);
	vector< pairT > pos(n);
	for (int i = 0; i < n; i++)
	{
		scanf("%d %d", &pos[i].first, &pos[i].second);
		is[pos[i].first + 100][pos[i].second + 100] = 1;
	}
	sort(pos.begin(), pos.end(), comp);
	for (int i = 0; i < n - 2; i++)
		for (int j = i + 1; j < n - 1; j++)
		{
			int cnt = 0, x1 = pos[i].first, y1 = pos[i].second, x2 = pos[j].first, y2 = pos[j].second,
				a = x1 - x2, b = y2 - y1, c = -a * y1 - b * x1, y;
			if (a == 0)
			{
				for (y = y2 + 1; y <= 100; y++)
					if (is[x1 + 100][y + 100] == 1)
						cnt++;
			}
			else
				for (int x = x2 + 1; x <= 100; x++)
					if (abs(b * x + c) % abs(a) == 0)
					{
						y = (b * x + c) / (-a);
						if (y >= -100 && y <= 100)
							if (is[x + 100][y + 100] == 1)
								cnt++;
					}
			ans += (ll)(n - (j + 1) - cnt);
		}
	printf("%lld", ans);
	return 0;
}


#include <bits/stdc++.h>

using namespace std;

#define rfile freopen("parties.in", "r", stdin)
#define wfile freopen("parties.out", "w", stdout)
#define files rfile; wfile
#define pb push_back

typedef long long ll;
typedef long double ld;
typedef vector< int > vi;
typedef vector< char > vc;
typedef vector< vc > vvc;
typedef vector< vi > vvi;
typedef map< int, int > mapT;
typedef pair< int, int > pairT;

const int inf = (int)1e9;
const int N = (int)211;

char is[N][N];

bool comp(pairT a, pairT b)
{
	if (a.first == b.first)
		return a.second < b.second;
	else
		return a.first < b.first;
}

int main()
{
	int n, x, y, ans = 0;
	scanf("%d", &n);
	vector< pairT > pos(n);
	for (int i = 0; i < n; i++)
	{
		scanf("%d %d", &pos[i].first, &pos[i].second);
		is[pos[i].first + 100][pos[i].second + 100] = 1;
	}
	sort(pos.begin(), pos.end(), comp);
	for (int i = 0; i < n - 2; i++)
		for (int j = i + 1; j < n - 1; j++)
		{
			int cnt = 0, x1 = pos[i].first, y1 = pos[i].second, x2 = pos[j].first, y2 = pos[j].second,
				a = x1 - x2, b = y2 - y1, c = -a * y1 - b * x1, y;
			if (a == 0)
			{
				for (y = y2 + 1; y <= 100; y++)
					if (is[x1 + 100][y] == 1)
						cnt++;
			}
			else
				for (int x = x2 + 1; x <= 100; x++)
					if (x != x1 && x != x2 && abs(b * x + c) % abs(a) == 0)
						if (is[x + 100][(b * x + c) / (-a) + 100] == 1)
							cnt++;
			ans += n - (j + 1) - cnt;
		}
	printf("%d", ans);
	return 0;
}


#include <bits/stdc++.h>

using namespace std;

#define rfile freopen("parties.in", "r", stdin)
#define wfile freopen("parties.out", "w", stdout)
#define files rfile; wfile
#define pb push_back

typedef long long ll;
typedef long double ld;
typedef vector< int > vi;
typedef vector< char > vc;
typedef vector< vc > vvc;
typedef vector< vi > vvi;
typedef map< int, int > mapT;
typedef pair< int, int > pairT;

const int inf = (int)1e9;
const int N = (int)211;

char is[N][N];

int main()
{
	int n, x, y, ans = 0;
	scanf("%d", &n);
	vector< pairT > pos(n);
	for (int i = 0; i < n; i++)
	{
		scanf("%d %d", &pos[i].first, &pos[i].second);
		is[pos[i].first + 100][pos[i].second + 100] = 1;
	}
	for (int i = 0; i < n - 2; i++)
		for (int j = i + 1; j < n - 1; j++)
		{
			int cnt = 0, x1 = pos[i].first, y1 = pos[i].second, x2 = pos[j].first, y2 = pos[j].second,
				a = x1 - x2, b = y2 - y1, c = -a * y1 - b * x1, y;
			if (a == 0)
			{
				for (y = -100; y <= 100; y++)
					if (is[x1 + 100][y] == 1)
						cnt++;
			}
			else
				for (int x = -100; x <= 100; x++)
					if (x != x1 && x != x2 && abs(b * x + c) % abs(a) == 0)
						if (is[x + 100][(b * x + c) / (-a) + 100] == 1)
							cnt++;
			ans += n - j - 1 - cnt;
		}
	printf("%d", ans);
	return 0;
}


#include <iostream>

using namespace std;

int fact(int x){
	if(x==1||x==0){
		return 1;
	} else{
		return x*fact(x-1);
	}
}

int main(){
	int n,flag=0;
	int combinaciones;

	cin >> n;
	//cout << n<<endl;
	long cordenadas[n*2];
	const int fact3 = fact(3);
	for(int i=0;i<n*2;i++){
			cin >> cordenadas[i];
	}

	if(n<3){
		cout << 0;
	} else{
		combinaciones = fact(n)/(fact3*fact(n-3));
		//cout << "combinaciones : " << combinaciones << endl;

		for(int i=0;i<n*2;i=i+2){
			if(cordenadas[i]==cordenadas[i+1]){
				flag++;
			}
		}

		combinaciones = combinaciones - (flag/3);
		cout << combinaciones << endl;
	}

 	return 0;
}


#include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <utility>
#include <vector>

#define PI 3.141592653589793
#define EPS 0.000000001
#define INF 1000000000

#define _ ios_base::sync_with_stdio(0), cin.tie(0), cin.tie(0), cout.tie(0), cout.precision(15);
#define FOR(i, a, b) for(int i=int(a); i<int(b); i++)
#define RFOR(i, a, b) for(int i=int(a)-1; i>=int(b); i--)
#define FORC(cont, it) for(typeof((cont).begin()) it = (cont).begin(); it != (cont).end(); it++)
#define RFORC(cont, it) for(typeof((cont).rbegin()) it = (cont).rbegin(); it != (cont).rend(); it++)
#define pb push_back
#define endl '\n'
#define all(x) x.begin(),x.end()

using namespace std;

typedef long long ll;
typedef pair<int, int> ii;
typedef vector<int> vi;
typedef vector<ii> vii;
typedef set<int> si;
typedef set<ll> sll;

const int MAXN = 2005;
int i,j,k,x[MAXN],y[MAXN],n;
int ans=0;
int main(){ _
   cin >> n;
   FOR(i, 0, n) cin >> x[i] >> y[i];
   FOR(i, 0, n - 1){
      FOR(j, i + 1, n - 1){
         FOR(k, j + 1, n){
            if((x[i] * (y[j] - y[k]) + x[j] * (y[k] - y[i]) + x[k] * (y[i] - y[j])))
               ans += 1;
         }
      }
   }
   cout << ans;
   return 0;
}


#include <iostream>

using namespace std;

long long fact(int x){
	if(x==1||x==0){
		return 1;
	} else{
		return x*fact(x-1);
	}
}

int main(){
	int n,flag=0;
	long long combinaciones;

	cin >> n;
	//cout << n<<endl;
	long cordenadas[n*2];
	const int fact3 = fact(3);
	for(int i=0;i<n*2;i++){
			cin >> cordenadas[i];
	}

	if(n<3){
		cout << 0;
	} else{
		combinaciones = fact(n)/(fact3*fact(n-3));
		//cout << "combinaciones : " << combinaciones << endl;

		for(int i=0;i<n*2;i=i+2){
			if(cordenadas[i]==cordenadas[i+1]){
				flag++;
			}
		}

		combinaciones = combinaciones - (flag/3);
		cout << combinaciones << endl;
	}

 	return 0;
}


#include <iostream>

using namespace std;

int fact(int x){
	if(x==1||x==0){
		return 1;
	} else{
		return x*fact(x-1);
	}
}

int main(){
	int n,flag=0;
	int combinaciones;

	cin >> n;
	//cout << n<<endl;
	int cordenadas[n*2];
	const int fact3 = fact(3);
	for(int i=0;i<n*2;i++){
			cin >> cordenadas[i];
	}

	if(n<3){
		cout << 0;
	} else{
		combinaciones = fact(n)/(fact3*fact(n-3));
		//cout << "combinaciones : " << combinaciones << endl;

		for(int i=0;i<n*2;i=i+2){
			if(cordenadas[i]==cordenadas[i+1]){
				flag++;
			}
		}

		combinaciones = combinaciones - (flag/3);
		cout << combinaciones << endl;
	}

 	return 0;
}


#include <iostream>

using namespace std;

long long fact(int x){
	if(x==1||x==0){
		return 1;
	} else{
		return x*fact(x-1);
	}
}

int main(){
	int n,flag=0;
	int combinaciones;

	cin >> n;
	//cout << n<<endl;
	long cordenadas[n*2];
	const int fact3 = fact(3);
	for(int i=0;i<n*2;i++){
			cin >> cordenadas[i];
	}

	if(n<3){
		cout << 0;
	} else{
		combinaciones = fact(n)/(fact3*fact(n-3));
		//cout << "combinaciones : " << combinaciones << endl;

		for(int i=0;i<n*2;i=i+2){
			if(cordenadas[i]==cordenadas[i+1]){
				flag++;
			}
		}

		combinaciones = combinaciones - (flag/3);
		cout << combinaciones << endl;
	}

 	return 0;
}


#include<iostream>
#include<cstring>
#include<vector>
#include<cstdlib>
#include<algorithm>

using namespace std;
vector<pair<int, int> > pts;
vector<pair<pair<int, int>, pair<int, int> > > vals;

int gcd(int n1, int n2)
{
	if(n1 < n2)
		swap(n1, n2);

	if(n2 == 0)
		return n1;

	return gcd(n2, n1 % n2);
}

pair<int, int> compute_slope(pair<int, int> p1, pair<int, int> p2)
{
	// cout<<"COMPUTE SLOPE\n";
	// cout<<p1.first<<" "<<p1.second<<endl;
	// cout<<p2.first<<" "<<p2.second<<endl;
	pair<int, int> slope;
	int ydiff = p2.second - p1.second;
	int xdiff = p2.first - p1.first;

	int gcdslope = gcd(abs(xdiff), abs(ydiff));
	// cout<<gcdslope<<endl;
	if(xdiff == 0)
		slope = make_pair(1, 0);
	else if(ydiff == 0)
		slope = make_pair(0, 1);
	else if(xdiff * ydiff < 0)
		slope = make_pair(-1 * abs(ydiff) / gcdslope, abs(xdiff) / gcdslope);
	else
		slope = make_pair(abs(ydiff) / gcdslope, abs(xdiff) / gcdslope);

	// cout<<slope.first<<" "<<slope.second<<endl;
	// cout<<"END OF SLOPE\n";
	return slope;
}

pair<int, int> compute_c(pair<int, int> p1, pair<int, int> p2)
{
	pair<int, int> c;
	int xdiff = p2.second - p1.second;
	int mixdiff = p1.first * p2.second - p2.first * p1.second;

	int gcdc = gcd(abs(xdiff), abs(mixdiff));
	if(xdiff == 0)
		c = make_pair(1, 0);
	else if(mixdiff == 0)
		c = make_pair(0, 1);
	else if(xdiff * mixdiff < 0)
		c = make_pair(-1 * abs(mixdiff) / gcdc, abs(xdiff) / gcdc);
	else
		c = make_pair(abs(mixdiff) / gcdc, abs(xdiff) / gcdc);

	return c;
}

int main()
{
	int n, inpx, inpy;
	cin>>n;

	for(int i = 0; i < n; i++)
	{
		cin>>inpx>>inpy;
		pts.push_back(make_pair(inpx, inpy));
	}

	for(int i = 0; i < n; i++)
	{
		for(int j = i + 1; j < n; j++)
		{
			pair<int, int> slope = compute_slope(pts[i], pts[j]);
			pair<int, int> cons = compute_c(pts[i], pts[j]);

			vals.push_back(make_pair(slope, cons));
		}
	}

	long long ans = n * (n - 1) * (n - 2) / 6;
	sort(vals.begin(), vals.end());

	int curr = 0;
	for(int i = 1; i < vals.size(); i++)
	{
		//cout<<vals[i].first.first<<" "<<vals[i].first.second<<" "<<vals[i].second.first<<" "<<vals[i].second.second<<endl;
		if((vals[i].first != vals[curr].first) || (vals[i].second != vals[curr].second))
		{
			//cout<<i<<endl;
			long long cnt = i - curr;
			if(cnt >= 3)
				ans -= (cnt * (cnt - 1) * (cnt - 2)) / 6;

			curr = i;
		}
	}
	long long cnt = vals.size() - curr;
	if(cnt >= 3)
		ans -= (cnt * (cnt - 1) * (cnt - 2)) / 6;

	cout<<ans;
	return 0;
}


#include<iostream>
#include<cstring>
#include<vector>
#include<cstdlib>
#include<algorithm>
#include<map>
#include<set>

using namespace std;
vector<pair<int, int> > pts;
map<pair<pair<int, int>, pair<int, int> >, set<int> > vals;

int gcd(int n1, int n2)
{
	if(n1 < n2)
		swap(n1, n2);

	if(n2 == 0)
		return n1;

	return gcd(n2, n1 % n2);
}

pair<int, int> compute_slope(int indx1, int indx2)
{
	// cout<<"COMPUTE SLOPE\n";
	pair<int, int> p1 = pts[indx1];
	pair<int, int> p2 = pts[indx2];
	// cout<<p1.first<<" "<<p1.second<<endl;
	// cout<<p2.first<<" "<<p2.second<<endl;
	pair<int, int> slope;
	int ydiff = p2.second - p1.second;
	int xdiff = p2.first - p1.first;

	int gcdslope = gcd(abs(xdiff), abs(ydiff));
	// cout<<gcdslope<<endl;
	if(xdiff == 0)
		slope = make_pair(1, 0);
	else if(ydiff == 0)
		slope = make_pair(0, 1);
	else if(xdiff * ydiff < 0)
		slope = make_pair(-1 * abs(ydiff) / gcdslope, abs(xdiff) / gcdslope);
	else
		slope = make_pair(abs(ydiff) / gcdslope, abs(xdiff) / gcdslope);

	// cout<<slope.first<<" "<<slope.second<<endl;
	// cout<<"END OF SLOPE\n";
	return slope;
}

pair<int, int> compute_c(int indx1, int indx2, pair<int, int> slope)
{
	// cout<<"COMPUTE constant\n";
	pair<int, int> p1 = pts[indx1];
	pair<int, int> p2 = pts[indx2];
	// cout<<p1.first<<" "<<p1.second<<endl;
	// cout<<p2.first<<" "<<p2.second<<endl;
	pair<int, int> c;
	int xdiff = p2.first - p1.first;
	int mixdiff = p1.first * p2.second - p2.first * p1.second;

	if(slope.first == 1 && slope.second == 0)
		return make_pair(p1.first, 0);

	int gcdc = gcd(abs(xdiff), abs(mixdiff));
	if(xdiff == 0)
		c = make_pair(1, 0);
	else if(mixdiff == 0)
		c = make_pair(0, 1);
	else if(xdiff * mixdiff < 0)
		c = make_pair(-1 * abs(mixdiff) / gcdc, abs(xdiff) / gcdc);
	else
		c = make_pair(abs(mixdiff) / gcdc, abs(xdiff) / gcdc);

	// cout<<c.first<<" "<<c.second<<endl;
	// cout<<"END OF constant\n";
	return c;
}

int main()
{
	int n, inpx, inpy;
	cin>>n;

	for(int i = 0; i < n; i++)
	{
		cin>>inpx>>inpy;
		pts.push_back(make_pair(inpx, inpy));
	}

	set<int>::iterator it;
	for(int i = 0; i < n; i++)
	{
		for(int j = i + 1; j < n; j++)
		{
			// cout<<i<<" "<<j<<" <----- indexes"<<endl;
			pair<int, int> slope = compute_slope(i, j);
			pair<int, int> cons = compute_c(i, j, slope);

			//cout<<vals[make_pair(slope, cons)].size()<<endl;
			vals[make_pair(slope, cons)].insert(i);
			vals[make_pair(slope, cons)].insert(j);
		}
	}

	long long ans = n * (n - 1) * (n - 2) / 6;
	map<pair<pair<int, int>, pair<int, int> >, set<int> >::iterator itr;
	int curr = 0;
	for(itr = vals.begin(); itr != vals.end(); itr++)
	{
		// cout<<endl;
		// cout<<((itr -> second).size())<<endl;

		// if((itr -> second).size() > 10)
		// {
		// 	cout<<((itr->first).first.first)<<" "<<((itr->first).first.second)<<endl;
		// 	cout<<((itr->first).second.first)<<" "<<((itr->first).second.second)<<endl;
		// 	for(it = (itr -> second).begin(); it != (itr -> second).end(); it++)
		// 		cout<<(*it)<<" ";
		// }
		long long cnt = (itr -> second).size();
		if(cnt >= 3)
			ans -= (cnt * (cnt - 1) * (cnt - 2)) / 6;
		//cout<<"ans -- > "<<ans<<endl;
	}

	cout<<ans;
	return 0;
}