#include <iostream>
#include <fstream>
#include <stdlib.h>

using namespace std;

struct {
    unsigned long long x, y;
} p[1000], m[1000000];

///p: A(x, y)
///m: dif de y/ dif de x => m[].x = dif de y
///                         m[].y = dif de x

ifstream fin("trapez.in");
ofstream fout("trapez.out");

int part_Hoare ( int s, int d )
{

    int i, j;
        i = s-1;
        j= d+1;
    int randpoz, r1, r2, r3;
    int nr = d-s+1;

    r1 = rand() % nr + s;
    r2 = rand() % nr + s;
    r3 = rand() % nr + s;

    int minr, maxr;
    minr = min ( min(r1, r2), min(r2, r3) );
    maxr = max ( max(r1, r2), max(r2, r3) );

    randpoz = r1+r2+r3 - minr-maxr;

    int pivot_x = m[randpoz].x;
    int pivot_y = m[randpoz].y;

    while (true){
        do
        {
            ++i;
        }while( m[i].x * pivot_y < m[i].y * pivot_x );
        do
        {
            --j;
        }while( m[j].x * pivot_y > m[j].y * pivot_x);
        if( i>=j )
            return j;
        //swap
        int aux_x, aux_y;
        aux_x = m[i].x;
        aux_y = m[i].y;
        m[i].x = m[j].x;
        m[i].y = m[j].y;
        m[j].x = aux_x;
        m[j].y = aux_y;
    }
}

void qsort (int i, int j)
{
    if(i<j){
        int k = part_Hoare( i, j );
        qsort(i, k);
        qsort(k+1, j);
    }
}

int main()
{
    int n, i;

    fin >> n;

    for(i=0; i<n; i++)
        fin >> p[i].x >> p[i].y;

    int j, k=-1, m_0 = 0;;

    for(i=0; i<n-1; i++)
        for(j=i+1; j<n; j++)
        {
            if( p[i].x == p[j].x )
                m_0++;
            else
            {
                m[++k].x = p[i].y - p[j].y;
                m[k].y = p[i].x - p[j].x;
            }
        }
    if( m_0 != 0 )
        m_0++;
    if( m_0 == 2 )
        m_0 = 1;
    else
        if( m_0 > 2 )
            m_0 *= m_0-1; ///combinari de m_0 luate cate 2

    qsort(0, k);

    int nr_total, nr_part;
    if(m_0 != 0)
        nr_total = m_0;
    else
        nr_total = 1;

    i=1;
    while ( i < n )
    {
        nr_part = 0;
        while( p[i].x * p[i-1].y == p[i].y * p[i-1].x )
        {
            nr_part++;
            i++;
        }
        if(nr_part != 0) //pt ca numara x-1 nr egale in loc de x
            nr_part++;
        ///daca nr_part e 2 atunci combinari de () o sa dea 1 si e elem neutru la inmultire
        if(nr_part > 2)
        {
            nr_part = nr_part*(nr_part-1);
            nr_total *= nr_part;
        }

        i++;
    }
    fout<<nr_total;
    return 0;

}