//#include <iostream>
#include <fstream>
#include <algorithm>
#include <math.h>
using namespace std;
ifstream ka("trapez.in");
ofstream ki("trapez.out");

const int N_MAX = 1000;

double patrat(double t)
{
    return t * t;
}

struct punct
{
    double x, y;
}puncte[N_MAX + 1];

struct dreapta
{
    punct p1, p2;
    bool operator < (const dreapta arg) const
    {
        if(p1.x == p2.x)
            return false;
        else if(arg.p1.x == arg.p2.x)
            return true;
        else if(fabs((p1.y - p2.y) / (p1.x - p2.x) - (arg.p1.y - arg.p2.y) / (arg.p1.x - arg.p2.x)) < 1e-14)
            return sqrt(patrat(p1.y - p2.y) + patrat(p1.x - p2.x)) - sqrt(patrat(arg.p1.y - arg.p2.y) + patrat(arg.p1.x - arg.p2.x)) < 1e-14;
        else
            return (p1.y - p2.y) / (p1.x - p2.x) - (arg.p1.y - arg.p2.y) / (arg.p1.x - arg.p2.x) < 1e-14;
    }
    bool operator == (const dreapta arg) const
    {
        return fabs((p1.y - p2.y) * (arg.p1.x - arg.p2.x) - (arg.p1.y - arg.p2.y) * (p1.x - p2.x)) < 1e-14;
    }
}drepte[N_MAX * N_MAX + 1];

int n, marime;
long long sol;

double distanta(int i)
{
    return sqrt(patrat(drepte[i].p1.y - drepte[i].p2.y) + patrat(drepte[i].p1.x - drepte[i].p2.x));
}

double impartire(int i)
{
    if(drepte[i].p1.x == drepte[i].p2.x)
        return 1000000000000000000;
    else
        return (drepte[i].p1.y - drepte[i].p2.y) / (drepte[i].p1.x - drepte[i].p2.x);
}

int main()
{
    ka >> n;
    for(int i = 1; i <= n; i++)
        ka >> puncte[i].x >> puncte[i].y;
    for(int i = 1; i <= n; i++)
    {
        for(int j = i + 1; j <= n; j++)
        {
            dreapta d;
            d.p1 = puncte[i];
            d.p2 = puncte[j];
            drepte[++marime] = d;
        }
    }
    sort(drepte + 1, drepte + marime + 1);
    //for(int i = 1; i <= marime; i++)
        //cout << drepte[i].p1.x << " " << drepte[i].p1.y << " " << drepte[i].p2.x << " " << drepte[i].p2.y << " " << impartire(i) << '\n';
    //cout << '\n';
    int egale = 1;
    int elemente = 1;
    for(int i = 2; i <= marime; i++)
    {
        if(!(drepte[i] == drepte[i - 1]))
        {
            sol += (elemente * (elemente - 1)) / 2;
            elemente = 1;
            egale = 1;
        }
        else if(fabs(distanta(i) - distanta(i - 1) < 1e-14))
        {
            egale++;
            elemente++;
        }
        else
        {
            sol += (egale * (egale - 1)) / 2;
            egale = 1;
            elemente++;
        }
    }
    ki << sol;
}