#include<iostream>
#include<algorithm>
#define maxn 1000010
#define maxl 10000010
#define offset 1
using namespace std;

struct Point{
    int x,y;
}points[maxn];

struct Rect{
    int a,b,c,d;
}rects[maxn];

struct Segment{
    int x,y1,y2;
    int qid; /* 对应的矩形id */
    bool left; /* 矩形的左侧边 */
}seg[maxn];

struct BIT{ // 树状数组
    int a[maxl];
    int lowbit(int x) {
        return x&-x;
    }
    int psum(int x){
        x += offset; // offset 用于避免纵坐标为0或负的情况
        int ans=0;
        while(x>0){
            ans+=a[x];
            x-=lowbit(x);
        }
        return ans;
    }
    int query(int l, int r){
        if(l>r)return 0;
        return psum(r)-psum(l-1);
    }
    void add(int x, int val){
        x += offset;
        while(x<=maxl){
            a[x]+=val;
            x+=lowbit(x);
        }
    }
}tr;

int ans[maxn];
void solve(int n,int q){
    // Step 1: 把平面上的点按横坐标排序
    sort(points+1,points+n+1,[](Point &a,Point &b){
        return a.x<b.x;
    });

    // Step 2: 把询问的矩形转换为需要query的线段
    int segptr=0;
    for(int i=1;i<=q;++i){
        seg[++segptr]={rects[i].a-1, rects[i].b, rects[i].d, i, true};
        seg[++segptr]={rects[i].c  , rects[i].b, rects[i].d, i, false};
    }
    sort(seg+1,seg+segptr+1,[](Segment &a,Segment &b){
        return a.x<b.x;
    });

    // Step 3: 扫描线遍历
    int pp=1,sp=1;
    while(pp<=n||sp<=segptr){
        if(sp>segptr || (pp<=n && points[pp].x<=seg[sp].x)){
            tr.add(points[pp].y,1);
            ++pp;
        }
        else{
            int num = tr.query(seg[sp].y1,seg[sp].y2);
            if(seg[sp].left) ans[seg[sp].qid]-=num; // 当前矩形的左侧边：排除矩形范围外的点
            else ans[seg[sp].qid]+=num; // 当前边是矩形的右侧边
            ++sp;
        }
    }

    // Step 4: 输出
    for(int i=1;i<=q;++i)cout<<ans[i]<<'\n';
}

#include<iostream>
#include<algorithm>
#include<stack>
#define maxn 100010
#define maxl 100010
#define offset 0
using namespace std;

struct Point{
    int a,b,c,num;
}in[maxn],points[maxn];

struct BIT{ // 树状数组
    int bit[maxl];
    stack<pair<int,int>>hist;
    int lowbit(int x) {
        return x&-x;
    }
    int psum(int x){
        x += offset;
        int ans=0;
        while(x>0){
            ans+=bit[x];
            x-=lowbit(x);
        }
        return ans;
    }
    int query(int l, int r){
        if(l>r)return 0;
        return psum(r)-psum(l-1);
    }
    void add(int x, int val, bool record){
        if(record)hist.push({x,val});
        x += offset;
        while(x<maxl){
            bit[x]+=val;
            x+=lowbit(x);
        }
    }
    void clear(){
        while(!hist.empty()){
            add(hist.top().first,-hist.top().second,false);
            hist.pop();
        }
    }
}tr;

int ans=0;
void divide(int l,int r){
    if(l>=r)return;
    int mid=(l+r)>>1;
    divide(l,mid);
    divide(mid+1,r);

    // 给分成两段的序列分别在第二维上排序
    sort(points+l, points+mid+1, [](Point &a, Point &b){
        if(a.b==b.b)return a.c<b.c;
        return a.b<b.b;
    });
    sort(points+mid+1, points+r+1, [](Point &a, Point &b){
        if(a.b==b.b)return a.c<b.c;
        return a.b<b.b;
    });

    // 设现在[l,mid]范围内的点为a，[mid+1,r]范围内的点为b，则经过排序后所有a都满足a.x<=b.x
    // 现在我们要找出满足题意的点对(i,j)，由于[l,mid]范围和[mid+1,r]范围内的(i,j)都在分治过程中找完了
    // 所以现在我们只关心i在[l,mid]，j在[mid+1,r]范围内的点对，我们需要按y从小到大来遍历这些点
    int i=l,j=mid+1;
    while(j<=r){
        if(i<=mid&&points[i].b<=points[j].b){
            tr.add(points[i].c, points[i].num, true);
            ++i;
        }
        else{
            ans+=tr.query(1,points[j].c)*points[j].num;
            ++j;
        }
    }
    tr.clear();
}

void solve(int n){
    // 给第一个维度进行排序
    sort(in+1, in+n+1, [](Point &a, Point &b){
        if(a.a==b.a){
            if(a.b==b.b)return a.c<b.c;
            return a.b<b.b;
        }
        return a.a<b.a;
    });
    int ptr=0;

    // 仅筛选出坐标不同的点，并求出坐标相同的点对答案的贡献
    for(int i=1;i<=n;++i){
        if(in[i].a!=points[ptr].a||in[i].b!=points[ptr].b||in[i].c!=points[ptr].c){
            ans+=points[ptr].num*(points[ptr].num-1);
            points[++ptr]=in[i];
            points[ptr].num=1;
        }
        else ++points[ptr].num;
    }
    ans+=points[ptr].num*(points[ptr].num-1);
    divide(1,ptr);
}