/*
/// VARIANTA 1
#include <iostream>
#include <fstream>
#include <algorithm>
#include <cmath>
using namespace std;

ifstream f ("patrate3.in");
ofstream g ("patrate3.out");

const int NMAX = 1000;
int n, sol;

struct punct {
    int x, y;
};

punct v[NMAX+1], A, B, C, D, O;

bool cmp (punct a, punct b) {
    if (a.x == b.x)
        return a.y < b.y;
    return a.x < b.x;
}

bool cautbin(punct P) {
    int p  = 1, u = n;
    while (p <= u) {
        int m = (p+u)/2;
        if (v[m].x == P.x) {
            if (v[m].y < P.y)
                p = m+1;
            else if (v[m].y > P.y)
                u = m-1;
            else
                return 1;
        } else if (v[m].x > P.x)
            u = m-1;
        else
            p = m+1;
    }
    return 0;
}

int main()
{
    f >> n;
    for (int i=1; i<=n; i++) {
        double x, y;
        f >> x >> y;
        v[i] = {round(x*10000), round(y*10000)};
    }
    sort (v+1, v+n+1, cmp);
    for (int i=1; i<n; i++)
        for (int j=i+1; j<=n; j++) {
            // Diagonala patratului
            A = v[i];
            C = v[j];
            // Mijlocul patratului
            O = {(A.x+C.x)/2, (A.y+C.y)/2};
            double dX = O.x - A.x,
                   dY = O.y - A.y;
            B = {O.x-dY, O.y+dX};
            D = {O.x+dY, O.y-dX};
            if (cautbin(B) && cautbin(D))
                sol++;
        }
    g << sol/2;
    f.close();
    g.close();
    return 0;
}
*/

/*
/// VARIANTA 2
#include <iostream>
#include <fstream>
#include <algorithm>
#include <cmath>
using namespace std;

ifstream f ("patrate3.in");
ofstream g ("patrate3.out");

const double EPS = 1e-5;

struct punct {
    double x, y;
};

int N;
punct P[1001];

int egal(double a, double b) {
    double d = a-b;
    if (d < -EPS) return -1;
    if (d > +EPS) return +1;
    return 0;
}

int egal(const punct &A, const punct &B) {
    int ex = egal(A.x, B.x),
        ey = egal(A.y, B.y);
    if (ex == 0) return ey;
    return ex;
}

bool cmp (const punct &a, const punct &b) {
    return egal(a, b) < 0;
}

bool cautbin(const punct &A) {
    int p  = 1, u = N;
    while (p <= u) {
        int m = (p+u)/2,
            e = egal(P[m], A);
        if (e == 0) return 1;
        if (e == 1) u = m - 1;
        else p = m + 1;
    }
    return 0;
}

void solve() {
    punct A, B, M;
    int nrp = 0;
    for (int i=1; i<N; i++)
    for (int j=i+1; j<=N; j++) {
        M.x = (P[i].x + P[j].x)/2;
        M.y = (P[i].y + P[j].y)/2;
        A.x = M.x - P[j].y + M.y;
        A.y = M.y + P[j].x - M.x;
        B.x = M.x + P[j].y - M.y;
        B.y = M.y - P[j].x + M.x;
        if (cautbin(A) && cautbin(B))
            nrp++;
    }
    g << nrp/2;
}

int main()
{
    f >> N;
    for (int i=1; i<=N; i++)
        f >> P[i].x >> P[i].y;
    sort(P+1, P+N+1, cmp);
    solve();
    f.close();
    g.close();
    return 0;
}
*/


/// VARIANTA 2
#include <iostream>
#include <fstream>
#include <algorithm>
#include <cmath>
using namespace std;

ifstream f ("patrate3.in");
ofstream g ("patrate3.out");

const double EPS = 1e-5;

struct punct {
    double x, y;
};

int N;
punct P[1001];

int egal(double a, double b) {
    double d = a-b;
    if (d < -EPS) return -1;
    if (d > +EPS) return +1;
    return 0;
}

int egal(const punct &A, const punct &B) {
    int ex = egal(A.x, B.x),
        ey = egal(A.y, B.y);
    if (ex == 0) return ey;
    return ex;
}

bool cmp (const punct &a, const punct &b) {
    return egal(a, b) < 0;
}

bool cautbin(const punct &A) {
    int p  = 1, u = N;
    while (p <= u) {
        int m = (p+u)/2,
            e = egal(P[m], A);
        if (e == 0) return 1;
        if (e == 1) u = m - 1;
        else p = m + 1;
    }
    return 0;
}

void solve() {
    punct A, B, M;
    int nrp = 0;
    for (int i=1; i<N; i++)
    for (int j=i+1; j<=N; j++) {
        A.x = P[i].x - P[j].y + P[i].y;
        A.y = P[i].y + P[j].x - P[i].x;
        B.x = P[j].x - P[j].y + P[i].y;
        B.y = P[j].y + P[j].x - P[i].x;
        if (cautbin(A) && cautbin(B))
            nrp++;
    }
    g << nrp/2;
}

int main()
{
    f >> N;
    for (int i=1; i<=N; i++)
        f >> P[i].x >> P[i].y;
    sort(P+1, P+N+1, cmp);
    solve();
    f.close();
    g.close();
    return 0;
}