#include <fstream>
#include <cmath>
#include <iostream>
#include <algorithm>

struct Point{
    double x, y;

    static inline double distance(Point const &A, Point const &B){
        return std::sqrt(std::pow(B.x - A.x, 2) + std::pow(B.y - A.y, 2));
    }

    inline bool operator < (Point const &P){
        return equal(x, P.x) ? y < P.y : x < P.x;
    }

    inline bool operator > (Point const &P){
        return equal(x, P.x) ? y > P.y : x > P.x;
    }

    void operator = (Point const &P){
        x = P.x;
        y = P.y;
    }

    friend void operator >> (std::ifstream& in, Point &P){
        in >> P.x >> P.y;
    }

    //real numbers equality precision
    static constexpr double epsilon = 0.001;

    static inline bool equal(double a, double b){
        return std::abs(a - b) < epsilon;
    }
};

std::ifstream fin("triang.in");
std::ofstream fout("triang.out");

Point v[1501];

int n;

int main()
{

    fin>>n;

    for(int i=1; i<=n; i++) fin >> v[i];

    std::sort(v + 1, v + n + 1, [](Point A, Point B){return A < B;});

    int triang{0};

    for(int i = 1; i <= n - 2; i++){
        for(int j = i + 1; j <= n - 1; j++){

            double d = Point::distance(v[i], v[j]);

            int first{j + 1}, last{n};

            while(first <= last){
                int mid = (first + last)/2;

                double d_j = Point::distance(v[j], v[mid]);

                if(Point::equal(d_j, d)){
                    double d_i = Point::distance(v[i], v[mid]);
                    if(Point::equal(d_i, d)) {
                            triang++;
                            break;
                    }
                    else if(d_i < d) first = mid + 1;
                    else last = mid - 1;
                }
                else if(d_j < d) first = mid + 1;
                else last = mid - 1;
            }



        }
    }

    fout << triang;
}