#include <bits/stdc++.h>
#define lowbit(x) (x & -x)
#define eb emplace_back
#define pb push_back
#define mp make_pair
using namespace std;

typedef long long ll;
const int N = 4e5+5;

int n;
int l[N], r[N], d[N], u[N], tmp[N];
ll ans;

struct Hsh {
	int v[N], c;
	inline void ins(int x) { v[++c] = x; }
	inline void init() {
		sort(v + 1, v + c + 1);
		c = unique(v + 1, v + c + 1) - v - 1;
	}
	inline int f(int x) { return lower_bound(v + 1, v + c + 1, x) - v; }
} Hx, Hy;

vector<int> L[N], R[N], D[N], U[N];

struct BIT {
	int R, T[N];
	inline void init(int r) {
		R = r;
		memset(T, 0, sizeof(T));
	}
	inline void upd(int x, int k) { for (; x <= R; x += lowbit(x)) T[x] += k; }
	inline int qry(int x) { int ret = 0; for (; x; x -= lowbit(x)) ret += T[x]; return ret; }
	inline int qry(int l, int r) {
		if (l > r) return 0;
		return qry(r) - qry(l - 1);
	}
} T1, T2;

namespace segT { 
	struct node {
		int cnt, ad;
		ll sum;
	} T[N << 2];
	
	#define ls (p << 1)
	#define rs (p << 1 | 1)
	
	void build(int p, int l, int r) {
		T[p].ad = T[p].sum = T[p].cnt = 0;
		if (l == r) return;
		int mid = (l + r) >> 1;
		build(ls, l, mid);
		build(rs, mid + 1, r);
	}
	
	inline void add(int p, ll k) { T[p].sum += k * T[p].cnt, T[p].ad += k; }
	inline void push_down(int p) { if (int &t = T[p].ad) add(ls, t), add(rs, t), t = 0; }
	inline void push_up(int p) { T[p].sum = T[ls].sum + T[rs].sum; }
	
	void upd1(int p, int l, int r, int gk, int k) {
		T[p].cnt++, T[p].sum += k;
		if (l == r) return;
		push_down(p);
		int mid = (l + r) >> 1;
		if (mid >= gk) upd1(ls, l, mid, gk, k);
		else upd1(rs, mid + 1, r, gk, k);
	}
	
	void upd2(int p, int l, int r, int gl, int gr, int k) {
		if (l >= gl && r <= gr) return add(p, k);
		push_down(p);
		int mid = (l + r) >> 1;
		if (mid >= gl) upd2(ls, l, mid, gl, gr, k);
		if (mid < gr) upd2(rs, mid + 1, r, gl, gr, k);
		push_up(p);
	}
	
	ll qry(int p, int l, int r, int gl, int gr) {
		if (l >= gl && r <= gr) return T[p].sum;
		ll ret = 0;
		push_down(p);
		int mid = (l + r) >> 1;
		if (mid >= gl) ret = qry(ls, l, mid, gl, gr);
		if (mid < gr) ret += qry(rs, mid + 1, r, gl, gr);
		return ret;
	}
	
	#undef ls
	#undef rs
}

int main() {
//	freopen("land.in", "r", stdin);
//	freopen("land.out", "w", stdout);
	scanf("%d", &n);
	for (int i = 1; i <= n; i++) {
		scanf("%d%d%d%d", &l[i], &r[i], &d[i], &u[i]);
		Hx.ins(l[i]), Hx.ins(r[i]);
		Hy.ins(d[i]), Hy.ins(u[i]);
	}
	
	Hx.init();
	Hy.init();
	
	for (int i = 1; i <= n; i++) {
		l[i] = Hx.f(l[i]), L[l[i]].pb(i);
		r[i] = Hx.f(r[i]), R[r[i]].pb(i);
		d[i] = Hy.f(d[i]), D[d[i]].pb(i);
		u[i] = Hy.f(u[i]), U[u[i]].pb(i);
	}
	
	ll cur = 0;
	T1.init(Hy.c), T2.init(Hy.c);
	for (int i = 1; i <= Hx.c; i++) {//情况1 
		for (int j : R[i]) {
			tmp[j] += T1.qry(1, d[j] - 1) + T2.qry(u[j] + 1, Hy.c);
			cur += tmp[j];
			T1.upd(u[j], 1), T2.upd(d[j], 1);
		}
		
		for (int j : L[i + 1]) {
			tmp[j] -= T1.qry(1, d[j] - 1) + T2.qry(u[j] + 1, Hy.c);
			ans += cur;
		}
	}
	
//	printf("1:%lld\n", ans);
	
	cur = 0;
	memset(tmp, 0, sizeof(tmp));
	T1.init(Hy.c), T2.init(Hy.c);
	for (int i = Hx.c; i >= 1; i--) {//情况2 
		for (int j : L[i]) {
			tmp[j] += T1.qry(1, d[j] - 1) + T2.qry(u[j] + 1, Hy.c);
			cur += tmp[j];
			T1.upd(u[j], 1), T2.upd(d[j], 1);
		}
		
		for (int j : R[i - 1]) {
			tmp[j] -= T1.qry(1, d[j] - 1) + T2.qry(u[j] + 1, Hy.c);
			ans += cur;
		}
	}
	
//	printf("2:%lld\n", ans);
	
	cur = 0;
	memset(tmp, 0, sizeof(tmp));
	for (int i = 1, rp = 1; i <= Hx.c; i++) {//情况3 
		while (rp <= Hx.c && Hx.v[rp] < Hx.v[i]) cur += R[rp++].size();
		for (int j : L[i]) tmp[j] = cur;
	}
	
	cur = 0;
	for (int i = Hx.c, lp = Hx.c; i >= 1; i--) {//情况3 
		while (lp >= 1 && Hx.v[lp] > Hx.v[i]) cur += L[lp--].size();
		for (int j : R[i]) ans += cur * tmp[j];
	}
	
//	printf("3:%lld\n", ans);
	
	segT::build(1, 1, Hx.c);
	T1.init(Hx.c), T2.init(Hx.c);
	for (int i = 1; i <= Hy.c; i++) {//情况4 
		for (int j : U[i]) {
			segT::upd1(1, 1, Hx.c, r[j], T2.qry(r[j] + 1, Hx.c));
			if (l[j] > 1) segT::upd2(1, 1, Hx.c, 1, l[j] - 1, 1);
			T1.upd(r[j], 1);
			T2.upd(l[j], 1);
		}
		
		for (int j : D[i + 1])
			ans += segT::qry(1, 1, Hx.c, l[j], r[j]) - (ll) T1.qry(l[j], r[j]) * T2.qry(r[j] + 1, Hx.c);
	}
	
//	printf("4:%lld\n", ans);
	
	segT::build(1, 1, Hx.c);
	T1.init(Hx.c), T2.init(Hx.c);
	for (int i = Hy.c; i >= 1; i--) {
		for (int j : D[i]) {
			segT::upd1(1, 1, Hx.c, r[j], T2.qry(r[j] + 1, Hx.c));
			if (l[j] > 1) segT::upd2(1, 1, Hx.c, 1, l[j] - 1, 1);
			T1.upd(r[j], 1);
			T2.upd(l[j], 1);
		}
		
		for (int j : U[i - 1])
			ans += segT::qry(1, 1, Hx.c, l[j], r[j]) - (ll) T1.qry(l[j], r[j]) * T2.qry(r[j] + 1, Hx.c);
	}
	
//	printf("5:%lld\n", ans);
	
	cur = 0;
	memset(tmp, 0, sizeof(tmp));
	T1.init(Hx.c), T2.init(Hx.c);
	for (int i = 1, up = 1; i <= Hy.c; i++) {//情况6 
		while (up <= Hy.c && Hy.v[up] < Hy.v[i]) {
			for (int j : U[up])
				T1.upd(r[j], 1), T2.upd(l[j], 1), cur++;
			up++;
		}
		for (int j : D[i])
			tmp[j] = cur - T1.qry(1, l[j] - 1) - T2.qry(r[j] + 1, Hx.c);
	}
	
	cur = 0;
	T1.init(Hx.c), T2.init(Hx.c);
	for (int i = Hy.c, dp = Hy.c; i >= 1; i--) {//情况6 
		while (dp >= 1 && Hy.v[dp] > Hy.v[i]) {
			for (int j : D[dp])
				T1.upd(r[j], 1), T2.upd(l[j], 1), cur++;
			dp--;
		}
		for (int j : U[i])
			ans += tmp[j] * (cur - T1.qry(1, l[j] - 1) - T2.qry(r[j] + 1, Hx.c));
	}
	
//	printf("6:%lld\n", ans);

	printf("%lld", ans);
	return 0;
}