// Problem: I. Intellectual Implementation
// Contest: Codeforces - 2021 Summer Petrozavodsk Camp, Day 3: IQ test (XXII Open Cup, Grand Prix of IMO)
// URL: https://codeforces.com/gym/103469/problem/I
// Memory Limit: 512 MB
// Time Limit: 6000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

#include <bits/stdc++.h>
#define pb emplace_back
#define fst first
#define scd second
#define mkp make_pair
#define mems(a, x) memset((a), (x), sizeof(a))

using namespace std;
typedef long long ll;
typedef double db;
typedef unsigned long long ull;
typedef long double ldb;
typedef pair<int, int> pii;

const int maxn = 1000100;
const int maxm = 200100;

int n, lsh[maxn], tot, b[maxn], bel[maxn], L[maxn], R[maxn], p[maxn], q[maxn], P[maxn], Q[maxn];
vector<pii> vc[maxn];
bitset<maxm> aa[500], bb[500], cc[500], dd[500], A, B;

struct node {
	int l, r, d, u, id;
} a[maxn];

struct BIT {
	int c[maxn];
	
	inline void init() {
		mems(c, 0);
	}
	
	inline void update(int x, int d) {
		for (int i = x; i < maxn; i += (i & (-i))) {
			c[i] += d;
		}
	}
	
	inline int query(int x) {
		int res = 0;
		for (int i = x; i; i -= (i & (-i))) {
			res += c[i];
		}
		return res;
	}
	
	inline int query(int l, int r) {
		return query(r) - query(l - 1);
	}
} b1, b2;

struct tnode {
	ll c0, c1, ans;
};

inline tnode operator + (const tnode &a, const tnode &b) {
	tnode res;
	res.c0 = a.c0 + b.c0;
	res.c1 = a.c1 + b.c1;
	res.ans = a.ans + b.ans + a.c1 * b.c0;
	return res;
}

namespace SGT {
	tnode a[maxn << 2];
	
	inline void pushup(int x) {
		a[x] = a[x << 1] + a[x << 1 | 1];
	}
	
	void update1(int rt, int l, int r, int x, int y) {
		if (l == r) {
			a[rt].c0 += y;
			return;
		}
		int mid = (l + r) >> 1;
		(x <= mid) ? update1(rt << 1, l, mid, x, y) : update1(rt << 1 | 1, mid + 1, r, x, y);
		pushup(rt);
	}
	
	void update2(int rt, int l, int r, int x, int y) {
		if (l == r) {
			a[rt].c1 += y;
			return;
		}
		int mid = (l + r) >> 1;
		(x <= mid) ? update2(rt << 1, l, mid, x, y) : update2(rt << 1 | 1, mid + 1, r, x, y);
		pushup(rt);
	}
	
	tnode query(int rt, int l, int r, int ql, int qr) {
		if (ql <= l && r <= qr) {
			return a[rt];
		}
		int mid = (l + r) >> 1;
		if (qr <= mid) {
			return query(rt << 1, l, mid, ql, qr);
		} else if (ql > mid) {
			return query(rt << 1 | 1, mid + 1, r, ql, qr);
		} else {
			return query(rt << 1, l, mid, ql, qr) + query(rt << 1 | 1, mid + 1, r, ql, qr);
		}
	}
}

void solve() {
	scanf("%d", &n);
	for (int i = 1; i <= n; ++i) {
		scanf("%d%d%d%d", &a[i].l, &a[i].r, &a[i].d, &a[i].u);
		a[i].id = i;
		lsh[++tot] = a[i].l;
		lsh[++tot] = a[i].r;
	}
	sort(lsh + 1, lsh + tot + 1);
	tot = unique(lsh + 1, lsh + tot + 1) - lsh - 1;
	for (int i = 1; i <= n; ++i) {
		a[i].l = lower_bound(lsh + 1, lsh + tot + 1, a[i].l) - lsh;
		a[i].r = lower_bound(lsh + 1, lsh + tot + 1, a[i].r) - lsh;
	}
	int t1 = tot;
	tot = 0;
	for (int i = 1; i <= n; ++i) {
		lsh[++tot] = a[i].d;
		lsh[++tot] = a[i].u;
	}
	sort(lsh + 1, lsh + tot + 1);
	tot = unique(lsh + 1, lsh + tot + 1) - lsh - 1;
	for (int i = 1; i <= n; ++i) {
		a[i].d = lower_bound(lsh + 1, lsh + tot + 1, a[i].d) - lsh;
		a[i].u = lower_bound(lsh + 1, lsh + tot + 1, a[i].u) - lsh;
	}
	int t2 = tot;
	for (int i = 1; i <= n; ++i) {
		p[i] = q[i] = P[i] = Q[i] = i;
	}
	sort(p + 1, p + n + 1, [&](const int &x, const int &y) {
		return a[x].r > a[y].r;
	});
	sort(q + 1, q + n + 1, [&](const int &x, const int &y) {
		return a[x].l < a[y].l;
	});
	sort(P + 1, P + n + 1, [&](const int &x, const int &y) {
		return a[x].u > a[y].u;
	});
	sort(Q + 1, Q + n + 1, [&](const int &x, const int &y) {
		return a[x].d < a[y].d;
	});
	int blo = sqrt(n);
	for (int i = 1; i <= n; ++i) {
		bel[i] = (i - 1) / blo + 1;
		if (!L[bel[i]]) {
			L[bel[i]] = i;
		}
		R[bel[i]] = i;
	}
	for (int i = 1; i <= bel[n]; ++i) {
		aa[i] = aa[i - 1];
		bb[i] = bb[i - 1];
		cc[i] = cc[i - 1];
		dd[i] = dd[i - 1];
		for (int j = L[i]; j <= R[i]; ++j) {
			aa[i].set(p[j]);
			bb[i].set(q[j]);
			cc[i].set(P[j]);
			dd[i].set(Q[j]);
		}
	}
	for (int i = 1; i <= n; ++i) {
		int l = 1, r = n, p1 = 0, p2 = 0, p3 = 0, p4 = 0;
		while (l <= r) {
			int mid = (l + r) >> 1;
			if (a[i].l <= a[p[mid]].r) {
				p1 = mid;
				l = mid + 1;
			} else {
				r = mid - 1;
			}
		}
		l = 1;
		r = n;
		while (l <= r) {
			int mid = (l + r) >> 1;
			if (a[q[mid]].l <= a[i].r) {
				p2 = mid;
				l = mid + 1;
			} else {
				r = mid - 1;
			}
		}
		l = 1;
		r = n;
		while (l <= r) {
			int mid = (l + r) >> 1;
			if (a[i].d <= a[P[mid]].u) {
				p3 = mid;
				l = mid + 1;
			} else {
				r = mid - 1;
			}
		}
		l = 1;
		r = n;
		while (l <= r) {
			int mid = (l + r) >> 1;
			if (a[Q[mid]].d <= a[i].u) {
				p4 = mid;
				l = mid + 1;
			} else {
				r = mid - 1;
			}
		}
		if (min({p1, p2, p3, p4}) == 0) {
			continue;
		}
		A = aa[bel[p1] - 1];
		for (int i = L[bel[p1]]; i <= p1; ++i) {
			A.set(p[i]);
		}
		B = bb[bel[p2] - 1];
		for (int i = L[bel[p2]]; i <= p2; ++i) {
			B.set(q[i]);
		}
		A &= B;
		B = cc[bel[p3] - 1];
		for (int i = L[bel[p3]]; i <= p3; ++i) {
			B.set(P[i]);
		}
		A &= B;
		B = dd[bel[p4] - 1];
		for (int i = L[bel[p4]]; i <= p4; ++i) {
			B.set(Q[i]);
		}
		A &= B;
		b[i] = (int)A.count() - 1;
	}
	// for (int i = 1; i <= n; ++i) {
		// printf("b[%d] = %d\n", i, b[i]);
	// }
	ll ans = 0;
	for (int i = 1; i <= n; ++i) {
		ans += 1LL * b[i] * (n - 2) - 1LL * b[i] * (b[i] - 1);
	}
	ans /= 2;
	for (int i = 1; i <= n; ++i) {
		vc[a[i].d].pb(i, 1);
		vc[a[i].u].pb(i, -1);
	}
	b1.init();
	b2.init();
	int cnt = 0;
	for (int i = 1; i <= t2; ++i) {
		for (pii p : vc[i]) {
			if (p.scd == 1) {
				int t = cnt - b1.query(a[p.fst].l - 1) - b2.query(a[p.fst].r + 1, t1);
				// printf("%d %d %lld\n", p.fst, t, SGT::query(1, 1, t1, a[p.fst].l, a[p.fst].r).ans);
				ans += 1LL * t * (t - 1) / 2 - SGT::query(1, 1, t1, a[p.fst].l, a[p.fst].r).ans;
				b1.update(a[p.fst].r, 1);
				b2.update(a[p.fst].l, 1);
				SGT::update1(1, 1, t1, a[p.fst].l, 1);
				SGT::update2(1, 1, t1, a[p.fst].r, 1);
			} else {
				b1.update(a[p.fst].r, -1);
				b2.update(a[p.fst].l, -1);
				SGT::update1(1, 1, t1, a[p.fst].l, -1);
				SGT::update2(1, 1, t1, a[p.fst].r, -1);
			}
			// printf("upd: %d %d %d\n", a[p.fst].l, a[p.fst].r, p.scd);
			cnt += p.scd;
		}
	}
	printf("%lld\n", 1LL * n * (n - 1) * (n - 2) / 6 - ans);
}

int main() {
	int T = 1;
	// scanf("%d", &T);
	while (T--) {
		solve();
	}
	return 0;
}