#include<bits/stdc++.h>
using namespace std;

typedef long long ll;
const int maxn=2e5+10;

inline int read(){
    int x=0,w=1;char c=getchar();
    while(c<'0'||c>'9'){if(c=='-')w=-1;c=getchar();}
    while(c<='9'&&c>='0'){x=(x<<3)+(x<<1)+c-'0';c=getchar();}
    return x*w;
}

int n;
struct Rectangle{
    int l,r,u,d;
    Rectangle()=default;
    Rectangle(int l_,int r_,int u_,int d_):l(l_),r(r_),u(u_),d(d_){}
}Rc[maxn];
struct Segment{
    int x,u,d,id;
    bool type;
    Segment()=default;
    Segment(int x_,int u_,int d_,int id_,bool type_):x(x_),u(u_),d(d_),id(id_),type(type_){}
}Sg[maxn<<1];
vector<int> Vx,Vy;
int X,Y;

struct BinaryIndexedTree{
#define lowbit(x) (x&-x)
    int sum[maxn<<1];
    inline void update(int x,int k){
        while(x<=Y){
            sum[x]+=k;
            x+=lowbit(x);
        }
    }
    inline int query(int x){
        if(!x||x>Y) return 0;
        int res=0;
        while(x){
            res+=sum[x];
            x-=lowbit(x);
        }
        return res;
    }
#undef lowbit
}Bu,Bd;

struct SegmentTree{
#define mid ((l+r)>>1)
#define lson rt<<1,l,mid
#define rson rt<<1|1,mid+1,r
    struct Data{
        ll C[4];
        ll& operator[](const int &i){return C[i];}
        ll operator[](const int &i)const{return C[i];}
    }val[maxn<<3];
    int tag[maxn<<3];
    inline void calc(Data &A,Data B,Data C){
        A[0]=B[0]*C[0];
        A[1]=B[0]*C[1]+B[1]*C[0];
        A[2]=B[0]*C[2]+B[1]*C[1]+B[2]*C[0];
        A[3]=B[0]*C[3]+B[1]*C[2]+B[2]*C[1]+B[3]*C[0];
    }
    inline Data get_Data(int k){
        Data res;
        res[0]=1,res[1]=1ll*k/1,res[2]=1ll*k*(k-1)/2,res[3]=1ll*k*(k-1)*(k-2)/6;
        return res;
    }
    inline void push_up(int rt){
        for(int i=0;i<4;++i) val[rt][i]=val[rt<<1][i]+val[rt<<1|1][i];
    }
    inline void push_down(int rt){
        if(tag[rt]){
            Data now=get_Data(tag[rt]);
            calc(val[rt<<1],val[rt<<1],now),calc(val[rt<<1|1],val[rt<<1|1],now);
            tag[rt<<1]+=tag[rt],tag[rt<<1|1]+=tag[rt];
            tag[rt]=0;
        }
    }
    void build(int rt,int l,int r){
        if(l==r) return val[rt][0]=1,void();
        build(lson),build(rson);
        push_up(rt);
    }
    void update(int rt,int l,int r,int pl,int pr,int k){
        if(pl<=l&&r<=pr){
            Data now=get_Data(k);
            calc(val[rt],val[rt],now);
            tag[rt]+=k;
            return;
        }
        push_down(rt);
        if(pl<=mid) update(lson,pl,pr,k);
        if(pr>mid) update(rson,pl,pr,k);
        push_up(rt);
    }
#undef mid
#undef lson
#undef rson
}S1,S2;

int deg[maxn];
ll ans;

int main(){
    n=read();
    for(int i=1,l,r,u,d;i<=n;++i){
        l=read(),r=read(),u=read(),d=read();
        Rc[i]=Rectangle(l,r,u,d);
        Vx.push_back(l),Vx.push_back(r);
        Vy.push_back(u),Vy.push_back(d);
    }
    sort(Vx.begin(),Vx.end());
    Vx.erase(unique(Vx.begin(),Vx.end()),Vx.end());
    sort(Vy.begin(),Vy.end());
    Vy.erase(unique(Vy.begin(),Vy.end()),Vy.end());
    X=Vx.size(),Y=Vy.size();
    for(int i=1;i<=n;++i){
        Rc[i].l=lower_bound(Vx.begin(),Vx.end(),Rc[i].l)-Vx.begin()+1;
        Rc[i].r=lower_bound(Vx.begin(),Vx.end(),Rc[i].r)-Vx.begin()+1;
        Rc[i].u=lower_bound(Vy.begin(),Vy.end(),Rc[i].u)-Vy.begin()+1;
        Rc[i].d=lower_bound(Vy.begin(),Vy.end(),Rc[i].d)-Vy.begin()+1;
        Sg[2*i-1]=Segment(Rc[i].l,Rc[i].u,Rc[i].d,i,0);
        Sg[2*i]=Segment(Rc[i].r,Rc[i].u,Rc[i].d,i,1);
    }
    sort(Sg+1,Sg+2*n+1,[&](Segment A,Segment B){
        if(A.x==B.x) return A.type<B.type;
        return A.x<B.x;
    });
    for(int i=1,j,cnt=0;i<=2*n;){
        j=i;
        while(j<=2*n&&Sg[j].x==Sg[i].x&&!Sg[j].type){
            deg[Sg[j].id]+=cnt-Bd.query(Sg[j].u-1)-(cnt-Bu.query(Sg[j].d));
            ++j;
        }
        j=i;
        while(j<=2*n&&Sg[j].x==Sg[i].x&&!Sg[j].type){
            Bu.update(Sg[j].u,1),Bd.update(Sg[j].d,1);
            ++cnt;
            ++j;
        }
        while(j<=2*n&&Sg[j].x==Sg[i].x&&Sg[j].type){
            Bu.update(Sg[j].u,-1),Bd.update(Sg[j].d,-1);
            --cnt;
            ++j;
        }
        i=j;
    }
    for(int i=1,j,cnt=0;i<=2*n;){
        j=i;
        while(j<=2*n&&Sg[j].x==Sg[i].x&&!Sg[j].type){
            Bu.update(Sg[j].u,1),Bd.update(Sg[j].d,1);
            ++cnt;
            ++j;  
        }
        j=i;
        while(j<=2*n&&Sg[j].x==Sg[i].x&&!Sg[j].type){
            deg[Sg[j].id]-=cnt-Bd.query(Sg[j].u-1)-(cnt-Bu.query(Sg[j].d));
            ++j;
        }
        while(j<=2*n&&Sg[j].x==Sg[i].x&&Sg[j].type){
            deg[Sg[j].id]+=cnt-Bd.query(Sg[j].u-1)-(cnt-Bu.query(Sg[j].d));
            ++j;
        }
        i=j;
    }
    for(int i=1;i<=2*n;++i){
        if(!Sg[i].type) Bu.update(Sg[i].u,-1),Bd.update(Sg[i].d,-1);
    }
    for(int i=1,j,cnt=0;i<=2*n;){
        j=i;
        while(j<=2*n&&Sg[j].x==Sg[i].x&&!Sg[j].type){
            Bu.update(Sg[j].u,1),Bd.update(Sg[j].d,1);
            ++cnt;
            ++j;  
        }
        j=i;
        while(j<=2*n&&Sg[j].x==Sg[i].x&&!Sg[j].type){
            deg[Sg[j].id]+=cnt-1-Bd.query(Sg[j].u-1)-(cnt-Bu.query(Sg[j].d));
            ++j;
        }
        j=i;
        while(j<=2*n&&Sg[j].x==Sg[i].x&&!Sg[j].type){
            Bu.update(Sg[j].u,-1),Bd.update(Sg[j].d,-1);
            --cnt;
            ++j;  
        }
        while(j<=2*n&&Sg[j].x==Sg[i].x&&Sg[j].type) ++j;
        i=j;
    }
    for(int i=1;i<=n;++i) ans-=1ll*deg[i]*(n-1-deg[i]);
    ans/=2;
    ans+=1ll*n*(n-1)*(n-2)/6;
    S1.build(1,1,Y);
    S2.build(1,1,Y);
    for(int i=1,j,cnt=0;i<=2*n;){
        j=i;
        while(j<=2*n&&Sg[j].x==Sg[i].x&&!Sg[j].type){
            ans+=S1.val[1][3]-S2.val[1][3];
            S1.update(1,1,Y,Sg[j].u,Sg[j].d,1);
            if(Sg[j].u<Sg[j].d) S2.update(1,1,Y,Sg[j].u,Sg[j].d-1,1);
            ans-=S1.val[1][3]-S2.val[1][3];
            ++j;
        }
        while(j<=2*n&&Sg[j].x==Sg[i].x&&Sg[j].type){
            S1.update(1,1,Y,Sg[j].u,Sg[j].d,-1);
            if(Sg[j].u<Sg[j].d) S2.update(1,1,Y,Sg[j].u,Sg[j].d-1,-1);
            ++j;
        }
        i=j;
    }
    printf("%lld\n",ans);
    return 0;
}