#include <iostream>
#include <fstream>
#include <set>
#include <algorithm>

using namespace std;

const int Nmax = 1000 + 2;
const double EPS = 1e-6;

class Point
{
public:

    double x, y;

    Point( const double _x = 0, const double _y = 0 )
    {
        x = _x;
        y = _y;
    }

    bool operator < ( const Point &P ) const
    {
        if ( abs( x - P.x ) <= EPS )
                return y < P.y;
        else
                return x < P.x;
    }

    bool operator == ( const Point &P ) const
    {
        return ( abs( x - P.x ) < EPS && abs( y - P.y ) < EPS );
    }
};

int N;
Point P[Nmax];
set <Point> US;

bool find( Point A )
{
    int st = 1, dr = N, m;

    while ( st <= dr )
    {
        m = ( st + dr ) / 2;

        if ( A == P[m] )
                return true;

        if ( A < P[m] )
                dr = m - 1;
        else
                st = m + 1;
    }

    return false;
}

int main()
{
    ifstream in("patrate3.in");
    ofstream out("patrate3.out");

    in >> N;

    for ( int i = 1; i <= N; ++i )
    {
        in >> P[i].x >> P[i].y;
    }

    sort( P + 1, P + N + 1 );

    int sol = 0;

    for ( int i = 1; i < N; ++i )
    {
        for ( int j = i + 1; j <= N; ++j )
        {
            Point A, B;

            A.x = P[i].x + P[i].y - P[j].y;
            A.y = P[i].y + P[j].x - P[i].x;
            B.x = P[j].x + P[i].y - P[j].y;
            B.y = P[j].y + P[j].x - P[i].x;

            if ( find( A ) && find( B ) )
                    sol++;
        }
    }

    out << sol / 2 << "\n";

    return 0;
}