#include <cstdio>
#include <algorithm>
#include <cmath>
#include <algorithm>
#include <iostream>
#include <stdio.h>
#include <math.h>
#include <bits/stdc++.h>

#define PI 3.14159265
#define mali 0.000001
using namespace std;

void heapify(double niz[], double a[], int n, int i)
{
    int najveci = i;
    int r = 2*i + 2;
    int l = 2*i + 1;
    if (r<n && (niz[r]>niz[najveci]||(abs(niz[r]-niz[najveci])<mali&&a[r]>a[najveci]))) najveci = r;

    if (l<n && (niz[l]>niz[najveci]||(abs(niz[l]-niz[najveci])<mali&&a[l]>a[najveci]))) najveci = l;


    if (najveci != i)
    {
        swap(niz[i], niz[najveci]);
        swap(a[i], a[najveci]);
        heapify(niz, a, n, najveci);
    }
}
void HeapSort(double niz[], double a[], int n)
{
    for (int i=n/2-1; i>=0; i--) heapify(niz, a, n, i);

    for (int i=n-1; i>0; i--)
    {
        swap(niz[0], niz[i]);
        swap(a[0], a[i]);
        heapify(niz, a, i, 0);
    }
}

int BinarySearch(double niz[], double a[], int l, int r, double x, double y)
{
    if (r >= l)
    {
        int mid = l + (r - l) / 2;

        if (abs(niz[mid]-x)<mali && abs(a[mid]-y)<mali) return mid;

        if (niz[mid] > x || (abs(niz[mid]-x)<mali && a[mid]>y)) return BinarySearch(niz, a, l, mid - 1, x, y);

        else return BinarySearch(niz, a, mid + 1, r, x, y);
    }

    return -1;
}



int x[1569];
int y[1569];
double duzina[1200000];
double ugao[1200000];

int main()
{
    ios_base::sync_with_stdio(false);
    cout<<setprecision(5);
    int n;
    cin>>n;
    for(int i = 0; i<n; i++)
    {
        cin>>x[i]>>y[i];
    }
    int k = 0;
    for(int i = 0; i<n; i++)
    {
        for(int j = i+1; j<n; j++)
        {
            duzina[k] = sqrt((x[i]-x[j])*(x[i]-x[j])+(y[i]-y[j])*(y[i]-y[j]));
            if(x[i] == x[j]) ugao[k]=90;
            else ugao[k]=(atan((y[i]-y[j])/(x[i]-x[j]))*180)/PI;
            k++;
        }
    }
    HeapSort(ugao, duzina, k);

    /*** Le DeBuging
    cout<<endl;
    for(int i = 0; i<k; i++)
    {
        cout<<ugao[i]<<" "<<duzina[i]<<endl;
    }
    ***/

    ///najgora funkcija svih vremena pocinje ovde
    long long suma = 0;
    int glavni = 0;
    int broj_pocetnih = 0;
    int broj_krajnjihA = 0;
    int broj_krajnjihB = 0;
    int krajnji = -1;
    while(glavni<k)
    {
        while(abs(ugao[glavni]-ugao[glavni+broj_pocetnih])<mali && abs(duzina[glavni]-duzina[glavni+broj_pocetnih])<mali)
        {
            broj_pocetnih++;
        }
        glavni+=broj_pocetnih-1;
        krajnji = BinarySearch(ugao, duzina, glavni, k, ugao[glavni], duzina[glavni]*2);
        if(krajnji!=-1)
        {
            while(abs(ugao[krajnji]-ugao[krajnji+broj_krajnjihA])<mali && abs(duzina[krajnji]-duzina[krajnji+broj_krajnjihA])<mali)
            {
                broj_krajnjihA++;
            }
            while(abs(ugao[krajnji]-ugao[krajnji-broj_krajnjihB])<mali && abs(duzina[krajnji]-duzina[krajnji-broj_krajnjihB])<mali)
            {
                broj_krajnjihB++;
            }
            suma+=broj_pocetnih*(broj_krajnjihA+broj_krajnjihB-1);
        }
        broj_pocetnih = 0;
        broj_krajnjihA = 0;
        broj_krajnjihB = 0;
        glavni++;
        krajnji = -1;



    }
    cout<<suma;
    ///moze i bolja optimizacija, steeeeta :D


    return 0;
}