#include<iostream>
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<bitset>
#include<random>
#include<cmath>
#include<ctime>
#include<queue>
#include<map>
#include<set>

#define int long long
#define __int128 long long
#define fi first
#define se second
#define max Max
#define min Min
#define abs Abs
#define lc (x<<1)
#define rc (x<<1|1)
#define mid ((l+r)>>1)
#define pb(x) push_back(x)
#define lowbit(x) ((x)&(-(x)))
#define fan(x) ((((x)-1)^1)+1)
#define mp(x,y) make_pair(x,y)
#define clr(f,n) memset(f,0,sizeof(int)*(n))
#define cpy(f,g,n) memcpy(f,g,sizeof(int)*(n))
#define SZ(x) ((int)(x.size()))
#define INF 0x3f3f3f3f

using namespace std;

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

inline void write(int x)
{
	if(x<0) putchar('-'),x=-x;
	if(x/10) write(x/10);
	putchar((char)(x%10)+'0');
}

template<typename T>inline T Abs(T a){return a>0?a:-a;};
template<typename T,typename TT>inline T Min(T a,TT b){return a<b?a:b;}
template<typename T,typename TT> inline T Max(T a,TT b){return a<b?b:a;}

const int N=1e6+5;
int n,m1,m2,nm[N];
__int128 ans;

struct Node
{
	int l,r,d,u,id;
}a[N],b[N];

bool cmp(Node a,Node b)
{
	return a.l<b.l;
}

namespace Part1
{
	struct BIT
	{
		int c[N];
		inline void add(int x,int v){for(;x<=m2;x+=lowbit(x))c[x]+=v;}
		inline int query(int x){int res=0;for(;x;x-=lowbit(x))res+=c[x];return res;}
		inline int query(int l,int r){if(l>r) return 0;return query(r)-query(l-1);}
		inline void clear(){for(int i=1;i<=m2;++i)c[i]=0;}
	}s1,s2;
	inline void solve()
	{
		sort(a+1,a+1+n,cmp);
		int tot=0,all=0;
		for(int i=1;i<=n;++i)
		{
			b[++tot]=(Node){a[i].l,1,a[i].d,a[i].u,a[i].id};
			b[++tot]=(Node){a[i].r+1,-1,a[i].d,a[i].u,a[i].id};
		}
		sort(b+1,b+1+tot,cmp);
		for(int i=1,j=0;i<=n;++i)
		{
			while(j+1<=tot&&b[j+1].l<=a[i].l)
				++j,s1.add(b[j].d,b[j].r),s2.add(b[j].u,b[j].r),all+=b[j].r;
			nm[a[i].id]+=all-s2.query(1,a[i].d-1)-s1.query(a[i].u+1,m2);
		}
		s1.clear();s2.clear();
		tot=0;all=0;
		for(int i=1;i<=n;++i)
		{
			b[++tot]=(Node){a[i].l,-1,a[i].d,a[i].u,a[i].id};
			b[++tot]=(Node){a[i].r,1,a[i].d,a[i].u,a[i].id};
		}
		sort(b+1,b+1+tot,cmp);
		for(int i=1,j=0;i<=tot;++i)
		{
			while(j+1<=n&&a[j+1].l<=b[i].l)
				++j,s1.add(a[j].d,1),s2.add(a[j].u,1),all++;
			nm[b[i].id]+=b[i].r*(all-s2.query(1,b[i].d-1)-s1.query(b[i].u+1,m2));
		}
	}
}

namespace Part2
{
	inline int C(int n,int m)
	{
		if(m==0) return 1;
		if(m==1) return n;
		if(m==2) return n*(n-1)/2;
		return n*(n-1)*(n-2)/6;
	}
	struct Seg
	{
		__int128 val[N<<2][4];
		int tg[N<<2];
		void upd(int x,int v)
		{
			for(int i=3;i>=0;--i)
			{
				int tmp=0;
				for(int j=0;j<=i;++j)
					tmp+=val[x][j]*C(v,i-j);
				val[x][i]=tmp;
			}
			tg[x]+=v;
		}
		void pushdown(int x)
		{
			if(tg[x])
			{
				upd(lc,tg[x]);
				upd(rc,tg[x]);
				tg[x]=0;
			}
		}
		void pushup(int x)
		{
			for(int i=0;i<=3;++i)
				val[x][i]=val[lc][i]+val[rc][i];
		}
		void update(int x,int l,int r,int L,int R,int v)
		{
			if(L<=l&&r<=R)
				return upd(x,v);
			pushdown(x);
			if(L<=mid) update(lc,l,mid,L,R,v);
			if(mid+1<=R) update(rc,mid+1,r,L,R,v);
			pushup(x);
		}
		void build(int x,int l,int r)
		{
			tg[x]=0;val[x][0]=1;
			val[x][1]=0;val[x][2]=0;val[x][3]=0;
			if(l==r) return;
			build(lc,l,mid);
			build(rc,mid+1,r);
			pushup(x);
		}
	}sg;
	inline void Solve(int dx,int dy,int w)
	{
		sg.build(1,1,m2);
		int tot=0;
		for(int i=1;i<=n;++i)
			if(a[i].l+dx<=a[i].r&&a[i].d+dy<=a[i].u)
			{
				b[++tot]=(Node){a[i].l+dx,1,a[i].d+dy,a[i].u,a[i].id};
				b[++tot]=(Node){a[i].r+1,-1,a[i].d+dy,a[i].u,a[i].id};
			}
		sort(b+1,b+1+tot,cmp);
		for(int i=1,j=0;i<=m1;++i)
		{
			while(j+1<=tot&&b[j+1].l<=i)
				++j,sg.update(1,1,m2,b[j].d,b[j].u,b[j].r);
			ans+=w*sg.val[1][3];
		}
	}
	inline void solve()
	{
		Solve(0,0,1);
		Solve(1,0,-1);
		Solve(0,1,-1);
		Solve(1,1,1);
	}
}

int d[N];

signed main()
{
	n=read();
	for(int i=1;i<=n;++i)
	{
		a[i].l=read();a[i].r=read();
		a[i].d=read();a[i].u=read();
		a[i].id=i;
	}
	for(int i=1;i<=n;++i)
		d[++m1]=a[i].l,d[++m1]=a[i].r;
	sort(d+1,d+1+m1);
	m1=unique(d+1,d+1+m1)-d-1;
	for(int i=1;i<=n;++i)
	{
		a[i].l=lower_bound(d+1,d+1+m1,a[i].l)-d;
		a[i].r=lower_bound(d+1,d+1+m1,a[i].r)-d;
	}
	for(int i=1;i<=n;++i)
		d[++m2]=a[i].d,d[++m2]=a[i].u;
	sort(d+1,d+1+m2);
	m2=unique(d+1,d+1+m2)-d-1;
	for(int i=1;i<=n;++i)
	{
		a[i].d=lower_bound(d+1,d+1+m2,a[i].d)-d;
		a[i].u=lower_bound(d+1,d+1+m2,a[i].u)-d;
	}
	Part1::solve();
	Part2::solve();
	int A=0,B=0;
	for(int i=1;i<=n;++i)
	{
		nm[i]--;
		B+=nm[i]*(nm[i]-1)/2;
		A+=(n-nm[i]-1)*(n-nm[i]-2)/2;
	}
	ans=(A+B-2*ans-n*(n-1)*(n-2)/6)/2;
	write(ans);
	return 0;
}