#include <bits/stdc++.h>
#define MAX 1010
#define f1 100000ll
#define f2 10000000000ll
#define f3 1000000000000000ll

typedef long long ll;
using namespace std;

struct Node
{
    int index;
    ll value;
    Node(){}
    Node(int index, ll value) : index(index), value(value) {}
    bool operator < ( const Node &o ) const
    {
        return value < o.value;
    }
};

ll xs[MAX];
ll ys[MAX];
vector<vector<Node>> values(MAX, vector<Node>(MAX));
ll dist[MAX][MAX];

int main()
{
    std::ios::sync_with_stdio(0);
    cin.tie(0);
    freopen("input.txt", "r", stdin);
    freopen("output.txt", "w", stdout);
    int n;
    while(cin>>n)
    {

    for( int i = 0; i < n; i++ )
    {
            cin>>xs[i]>>ys[i];
    }
    ll dx, dy;
    for( int i = 0; i < n; i++ )
    {
        for( int j = 0; j < n; j++)
        {
            dx = xs[i] - xs[j];
            dy = ys[i] - ys[j];
            dist[i][j] = dx*dx + dy*dy;
            values[i][j] = Node(j, dist[i][j] );
        }
        sort( values[i].begin(), values[i].begin() + n);
//        for( int j = 0; j < n; j++ )
//        {
//            cout<<values[i][j].index<<" "<<values[i][j].value<<endl;
//        }
//        cout<<endl<<endl;
    }
    ll d1, d2, d3;
    dx = xs[0] - xs[1];
    dy = ys[0] - ys[1];
    d1 = dx*dx+dy*dy;
    dx = xs[1] - xs[2];
    dy = ys[1] - ys[2];
    d2 = dx*dx+dy*dy;
    dx = xs[2] - xs[0];
    dy = ys[2] - ys[0];
    d3 = dx*dx+dy*dy;
    ll d2p, d3p;
    vector<Node>::iterator low, up;
    Node aux;
    ll v;
    set<ll> result;
    for( int i = 0; i < n; i++ )
    {
        for( int j = 0; j < n; j++ )
        {
            if ( i == j ) continue;
            d2p = d2*dist[i][j];
            d3p = d3*dist[i][j];
            if ( d2p % d1 != 0 ) continue;
            if ( d3p % d1 != 0 ) continue;
            d2p /= d1;
            d3p /= d1;
            low = lower_bound( values[j].begin(), values[j].begin()+n, Node(-1, d2p) );
            up = upper_bound( values[j].begin(), values[j].begin()+n, Node(-1, d2p) );
            while( low != up )
            {
                aux = values[j][low-values[j].begin()];
                if ( aux.index != i && aux.index != j && dist[aux.index][i] == d3p )
                {

                    if ( i > j && i > aux.index )
                    {
                        v = i*f1;
                        if ( j > aux.index )
                        {
                            v += j*f2;
                            v += aux.index*f3;
                        }
                        else
                        {
                            v += aux.index*f2;
                            v += j*f3;
                        }
                    }
                    else if ( j > i && j > aux.index )
                    {
                        v = j*f1;
                        if ( i > aux.index )
                        {
                            v += i*f2;
                            v += aux.index*f3;
                        }
                        else
                        {
                            v += aux.index*f2;
                            v += i*f3;
                        }
                    }
                    else
                    {
                        v = aux.index*f1;
                        if ( i > j )
                        {
                            v += i*f2;
                            v += j*f3;
                        }
                        else
                        {
                            v += j*f2;
                            v += i*f3;
                        }
                    }
                    //cout<<i<<" "<<j<<" "<<aux.index<<" "<<v<<endl;
                    result.insert(v);
                }

                ++low;
            }
        }
    }
    cout<<result.size()<<"\n";

    }
}