#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;
}