81
9 4
6 8
6 4
4 6
4 8
9 10
0 2
5 4
8 9
7 7
10 5
4 4
7 8
3 7
2 1
5 5
2 7
8 6
2 8
10 7
5 8
0 10
10 0
4 9
4 2
10 3
6 6
3 8
5 3
8 8
10 9
1 1
0 9
8 1
1 8
0 7
10 4
3 6
7 6
1 9
8 3
8 10
4 5
3 4
7 5
2 0
0 6
2 4
7 4
6 3
1 6
10 8
1 5
6 5
0 0
9 0
7 3
3 2
2 6
4 0
8 7
10 10
3 0
0 5
3 9
5 1
6 0
1 4
0 1
1 2
6 2
9 7
6 10
1 3
1 7
2 5
5 10
10 2
5 6
6 7
2 3
 1
0 0
 3
5 1
4 1
2 6
 54
0 8
3 2
9 3
7 2
8 2
2 8
10 10
7 6
1 1
9 7
4 0
6 10
10 1
10 8
5 1
0 4
7 10
3 6
0 5
4 3
3 0
5 10
6 9
5 4
6 6
8 5
0 7
5 8
1 2
2 2
9 4
2 4
0 10
5 9
10 9
7 9
9 9
2 5
4 10
8 9
7 7
5 2
6 5
4 1
10 6
6 3
9 6
0 9
7 3
7 5
8 4
1 3
0 3
2 10
 49
2 9
7 0
8 0
10 3
2 10
6 10
6 2
9 7
1 9
4 6
5 4
1 0
9 4
6 9
5 6
7 9
10 10
8 2
3 10
0 8
4 4
5 7
0 0
9 1
0 7
2 0
1 7
10 0
3 5
8 5
6 4
0 4
2 7
4 1
10 2
2 4
8 4
0 9
3 4
4 9
7 7
10 9
2 3
7 2
5 8
4 7
10 8
7 6
1 8
 72
8 2
2 4
3 5
9 10
7 6
1 5
0 0
3 3
1 6
7 10
8 8
7 9
6 0
3 6
9 3
8 1
3 4
3 7
0 7
10 8
2 6
6 8
0 6
5 6
6 6
6 5
6 4
0 2
9 9
4 8
7 2
8 0
9 4
0 10
4 5
9 8
10 3
8 7
8 5
7 7
6 7
5 7
5 4
8 4
3 2
7 3
9 0
0 8
0 5
3 9
2 10
7 1
4 3
1 10
3 0
5 9
10 1
6 1
4 10
1 0
2 1
2 0
3 8
10 7
7 4
0 9
1 1
1 8
8 3
5 2
6 3
4 2
 71
5 3
1 10
10 3
5 2
3 5
10 9
10 2
1 5
9 5
8 9
2 3
2 6
8 4
6 3
0 2
9 4
2 0
7 7
10 0
4 0
1 4
1 6
4 5
6 1
8 2
0 0
0 1
3 7
3 10
4 8
4 6
3 8
1 0
9 10
9 9
6 5
7 1
10 1
6 6
3 4
4 3
4 2
4 10
9 6
7 3
6 8
5 5
4 9
0 7
0 9
8 10
2 7
1 7
7 2
5 8
1 2
3 6
10 8
0 8
3 1
1 3
9 3
7 6
6 7
4 4
0 3
2 2
5 10
2 9
0 5
7 0
 3
1 6
10 8
4 3
 1
100000 100000
 87
5 10
5 0
9 2
2 4
6 6
4 4
3 4
0 3
10 6
1 0
7 1
2 5
6 10
5 3
1 6
8 7
5 6
5 9
9 8
2 6
6 9
6 4
3 2
10 10
0 4
8 9
8 8
4 8
10 2
10 0
3 8
8 2
3 1
9 5
9 1
5 4
4 6
10 7
2 0
10 9
9 0
9 9
6 2
3 9
10 8
7 0
7 3
6 0
5 2
6 5
4 7
1 3
9 7
1 5
4 1
7 10
0 2
0 8
9 10
0 5
4 10
7 4
1 8
2 7
10 3
9 3
10 5
6 1
8 3
10 1
8 0
5 1
3 10
10 4
2 10
4 5
5 7
7 9
1 7
8 6
1 1
7 2
7 5
5 5
1 4
6 8
6 3

85
 0
 0
 14
 11
 51
 40
 0
 0
 101

#include <iostream>
#include <cstdio>
#include <vector>
#include <string>
#include <algorithm>
#include <cstring>
#include <queue>
#include <set>
#include <cstdlib>
#include <cassert>
#include <cmath>
#include <map>
#include <cctype>
#include <unordered_set>
#include <unordered_map>

#define DEBUG 0

#if (DEBUG == 1)
    #define debug(fmt, ...) fprintf(stderr, fmt, ##__VA_ARGS__)
#else
    #define debug(fmt, ...)
#endif

#define INFTY 2000000000
#define INFTYLL 4000000000000000000LL
using namespace std;

typedef pair<int,int> pint;
typedef long long int lint;
typedef unsigned int unint;

/* FAST IO ********************** */
int onechar() {
    static const int BUFSIZE = 1<<20;
    static char buf[BUFSIZE], *ptr = buf+BUFSIZE;
    if (ptr == buf+BUFSIZE) {
        fread(buf, 1, BUFSIZE, stdin);
        ptr = buf;
    }
    return *ptr++;
}
int nextint() {
    char c;
    while (!isdigit(c = onechar()) && c != '-') ;
    int ans = c == '-' ? 0 : c-'0',
        sign = c == '-' ? -1 : 1;
    while (isdigit(c = onechar())) ans = ans * 10 + c-'0';
    return ans * sign;
}
char nextchar() { char c; while (isspace(c = onechar())); return c; }
string nextstring() {
    char c; string ret; while (!isspace(c = onechar())) ret += c;
    return ret;
}

/* ****************************** */

template <typename T> vector<T>& operator+=(vector<T> &v, const T &e) { v.push_back(e); return v; }
template <typename T> string tobin(T n) { string ret; do ret = char('0'+(n&1)) + ret; while (n /= 2); return ret; }
inline unint nextbitperm(unint mask) {
    unint ile = __builtin_ctz (mask), t = ~(mask>>ile), q = __builtin_ctz (t);
    return ~(((((((t>>q)-1)<<1)+1)<<ile)|((1<<(ile))-1))<<(q-1));
}

/* ****************************** */

/*
namespace std { namespace tr1 {
template <> struct hash< vector<int> > {
    size_t operator()(const std::vector<int>& v) const {
        size_t ret = 0, tmp = 1;
        for (int i=0; i<v.size(); i++, tmp *= 1000000009) {
            ret += tmp * v[i];
        }
        return ret;
    }
};
}}
*/

/* ****************************** */

template <typename T> struct RefType { typedef T& Ref; };
template <> struct RefType<bool> { typedef std::_Bit_reference Ref; };
template <typename T>
struct Vector
{
    vector<T> data;
    Vector(int s=0, const T& elem=T()) : data(s, elem) {}
    void push_back(const T& elem) { data.push_back(elem); }
    unsigned int size() const { return data.size(); }
    typename RefType<T>::Ref operator[](int k) {
        if (k<0 || k>=data.size()) {
            fprintf(stderr, "AAAAAAAAAAAAAAAA %d / %d\n", k, (int)data.size());
            abort();
        }
        return data[k];
    }
    T operator[](int k) const {
        if (k<0 || k>=data.size()) {
            fprintf(stderr, "const AAAAAAAAAAAAAAAA %d / %d\n", k, (int)data.size());
            while (true) ;
        }
        return data[k];
    }
    void clear() { data.clear(); }
    void resize(int n, const T& elem = T()) { data.resize(n, elem); }
};

/* ******************************* */

class Num
{
    static constexpr long long int MOD = 1000000007LL;
    long long val;
public:
    long long int get() const {
        return val;
    }
    Num(long long int x = 0LL) : val(x) {}
    Num operator+(const Num& other) const {
        return (val + other.val) % MOD;
    }
    Num operator*(const Num& other) const {
        return val * other.val % MOD;
    }
    Num operator-(const Num& other) const {
        return (val - other.val + MOD) % MOD;
    }
    static Num power(const Num& num, long long int k) {
        Num res = 1LL, curr = num;
        while (k) {
            if (k&1LL) 
                res = res * curr;
            curr = curr * curr;
            k /= 2LL;
        }
        return res;
    }
    Num power(long long int k) const {
        return power(*this, k);
    }
    Num operator/(const Num& other) const {
        Num res = (*this) * power(other, MOD-2);
        assert((res * other).get() == this->get());
        return res;
    }
};

/* ****************************** */
const int MAXROW = 100001;
vector<int> rows[MAXROW], cols[MAXROW];
lint enc(int r, int c) { return MAXROW*r + c; }
int main()
{
    ios_base::sync_with_stdio(false);
    int N;
    scanf("%d", &N);
    vector<pint> v(N);
    unordered_set<lint> pnts;
    for (int i=0; i<N; i++) {
        int r, c;
        scanf("%d %d", &r, &c);
        rows[r].push_back(c);
        pnts.insert(enc(r,c));
    }
    
    int count = 0;
    const int L = 305;
    for (int r=0; r<MAXROW; r++) {
        int rsize = rows[r].size();
        if (rsize == 0) continue;
        if (rsize <= L) {
            for (int i=0; i<rsize; i++)
                for (int j=i+1; j<rsize; j++) {
                    int c1 = rows[r][i], c2 = rows[r][j], d = abs(c1-c2);
                    
                    count += pnts.count(enc(r-d, c1)) * pnts.count(enc(r-d, c2));
                    count += pnts.count(enc(r+d, c1)) * pnts.count(enc(r+d, c2));
                }
        }
        else {
            for (int c: rows[r])
                cols[c].push_back(r);
        }
    }
    
    for (int c=0; c<MAXROW; c++) {
        int csize = cols[c].size();
        if (csize == 0) continue;
        for (int i=0; i<csize; i++)
            for (int j=i+1; j<csize; j++) {
                int r1 = cols[c][i], r2 = cols[c][j], d = abs(r1-r2);
                
                count += pnts.count(enc(r1, c-d)) * pnts.count(enc(r2, c-d));
                count += pnts.count(enc(r1, c+d)) * pnts.count(enc(r2, c+d));
            }
    }
    
    printf("%d\n", count/2);
    
    return 0;
}
