#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops")
#pragma GCC target("sse,sse2,sse3,sse3,sse4,popcnt,abm,mmx,avx,avx2")
// #define ATC
#define LL long long
#define eb emplace_back
#define writesp(x) write(x), putchar(' ')
#define writeln(x) write(x), putchar('\n')
#define FIO(FILENAME) freopen(FILENAME".in", "r", stdin), freopen(FILENAME".out", "w", stdout)
using namespace std;

#ifdef ATC
#include <atcoder/all>
using namespace atcoder;
#endif

namespace IO {
	char ibuf[(1 << 20) + 1], *iS, *iT;
#if ONLINE_JUDGE
#define gh() (iS == iT ? iT = (iS = ibuf) + fread(ibuf, 1, (1 << 20) + 1, stdin), (iS == iT ? EOF : *iS++) : *iS++)
#else
#define gh() getchar()
#endif
	inline long long read() {
		char ch = gh();
		long long x = 0;
		bool t = 0;
		while (ch < '0' || ch > '9') t |= ch == '-', ch = gh();
		while (ch >= '0' && ch <= '9') x = (x << 1) + (x << 3) + (ch ^ 48), ch = gh();
		return t ? ~(x - 1) : x;
	}
	template<typename _Tp>
	inline void write(_Tp x) {
		static char stk[64], *top = stk;
		if (x < 0) {
			x = ~(x - 1);
			putchar('-');
		}
		do *top++ = x % 10, x /= 10;
		while (x);
		while (top != stk) putchar((*--top) | 48);
	}
}

using IO::read;
using IO::write;

using cint = const int;

constexpr int N = 2e5 + 500;
int n, m, d[N], b[N << 1];

struct Node {
	int p[4], id;
	int& operator [] (const int &i) {
		return p[i];
	}
} a[N], c[N];

struct BIT {
	int tr[N << 1];
#define lowbit(x) (x & -x)
	void mdy (int x, int v) {
		for (; x <= m; x += lowbit(x)) tr[x] += v;
	}
	void clr () {
		memset(tr, 0, m + 1 << 2);
	}
	int qry (int x) {
		int r = 0;
		for (; x; x -= lowbit(x)) r += tr[x];
		return r;
	}
	int qry (int l, int r) {
		return qry(r) - qry(l - 1);
	}
} t, L, R;

struct SGT {
	struct Node {
		LL s;
		int l, r;
		Node (LL _s = 0, int _l = 0, int _r = 0) : s(_s), l(_l), r(_r) {}
		Node operator + (const Node &rhs) const {
			Node res;
			res.l = l + rhs.l;
			res.r = r + rhs.r;
			res.s = (LL)r * rhs.l + s + rhs.s;
			return res;
		}
	} tr[N << 3];
#define ls (p << 1)
#define rs (p << 1 | 1)
	void pushup (int p) {
		tr[p] = tr[ls] + tr[rs];
	}
	void updL (int s, int l, int r, int p, int v) {
        tr[p].l += v;
		if (l == r) {
			return;
		}
		cint mid = (l + r) >> 1;
		s <= mid ? updL(s, l, mid, ls, v) : updL(s, mid + 1, r, rs, v);
        tr[p].s = tr[ls].s + tr[rs].s + tr[ls].r * tr[rs].l;
	}
	void updR (int s, int l, int r, int p, int v) {
        tr[p].r += v;
		if (l == r) {
			return;
		}
		cint mid = (l + r) >> 1;
		s <= mid ? updR(s, l, mid, ls, v) : updR(s, mid + 1, r, rs, v);
        tr[p].s = tr[ls].s + tr[rs].s + tr[ls].r * tr[rs].l;
	}
	Node qry (int s, int t, int l, int r, int p) {
		if (s <= l && r <= t) return tr[p];
		cint mid = (l + r) >> 1;
		if (t <= mid) return qry(s, t, l, mid, ls);
		if (mid < s) return qry(s, t, mid + 1, r, rs);
		return qry(s, t, l, mid, ls) + qry(s, t, mid + 1, r, rs);
	}
} s;

namespace BF1 {
	inline void slv (int p) {
		if (p & 1) {
			for (int i = 1; i <= n; i++) {
				a[i][p] = m - a[i][p] + 1;
				a[i][p ^ 1] = m - a[i][p ^ 1] + 1;
			}
		}
		sort(a + 1, a + n + 1, [&](Node i, Node j) {
			return i[p] < j[p];
		});
		t.clr();
		for (int i = 1; i <= n; i++) {
			d[a[i].id] += t.qry(a[i][p]);
			t.mdy(a[i][p ^ 1], 1);
		}
		if (p & 1) {
			for (int i = 1; i <= n; i++) {
				a[i][p] = m - a[i][p] + 1;
				a[i][p ^ 1] = m - a[i][p ^ 1] + 1;
			}
		}
	}
	inline void main () {
		for (int i = 0; i < 4; i++) slv(i);
	}
}

namespace BF2 {
	inline void slv (int p) {
		if (p) {
			for (int i = 1; i <= n; i++) {
				a[i][0] = m - a[i][0] + 1;
				a[i][1] = m - a[i][1] + 1;
			}
		}
		memcpy(c, a, (n + 1) * sizeof(Node));
		sort(a + 1, a + n + 1, [&](Node i, Node j) {
			return i[p] < j[p];
		});
		sort(c + 1, c + n + 1, [&](Node i, Node j) {
			return i[p ^ 1] < j[p ^ 1];
		});
		L.clr(), R.clr();
		for (int i = 1, j = 1; i <= n; i++) {
			while (j <= n && c[j][p ^ 1] < a[i][p]) {
				L.mdy(c[j][2], 1);
				R.mdy(c[j][3], 1);
				++j;
			}
			d[a[i].id] -= R.qry(1, a[i][2]) + L.qry(a[i][3], m);
		}
		if (p) {
			for (int i = 1; i <= n; i++) {
				a[i][0] = m - a[i][0] + 1;
				a[i][1] = m - a[i][1] + 1;
			}
		}
	}
	inline void main () {
		for (int i = 0; i < 2; i++) slv(i);
	}
}

namespace BF3 {
	inline LL main () {
		memcpy(c, a, (n + 1) * sizeof(Node));
		sort(a + 1, a + n + 1, [&](Node i, Node j) {
			return i[0] < j[0];
		});
		sort(c + 1, c + n + 1, [&](Node i, Node j) {
			return i[1] < j[1];
		});
		LL r = 0;
		L.clr(), R.clr();
		for (int i = 1, j = 1; i <= n; i++) {
			while (j <= n && c[j][1] < a[i][0]) {
				s.updL(c[j][2], 1, m, 1, -1);
				s.updR(c[j][3], 1, m, 1, -1);
				L.mdy(c[j][2], -1);
				R.mdy(c[j][3], -1);
				++j;
			}
			int all = (i - j) - R.qry(1, a[i][2]) - L.qry(a[i][3], m);
			r += (LL)all * (all - 1) / 2 - s.qry(a[i][2], a[i][3], 1, m, 1).s;
			s.updL(a[i][2], 1, m, 1, 1);
			s.updR(a[i][3], 1, m, 1, 1);
			L.mdy(a[i][2], 1);
			R.mdy(a[i][3], 1);
		}
		return r;
	}
}

int main() {
	n = read();
	for (int i = 1; i <= n; i++) {
		for (int j = 0; j < 4; j++) a[i][j] = read();
		a[i].id = i;
	}
	for (int j = 0; j < 4; j += 2) {
		static auto gtp = [&](int &x) { x = lower_bound(b + 1, b + m + 1, x) - b; };
		m = 0;
		for (int i = 1; i <= n; i++) b[++m] = a[i][j], b[++m] = a[i][j ^ 1];
		sort(b + 1, b + m + 1);
		for (int i = 1; i <= n; i++) gtp(a[i][j]), gtp(a[i][j ^ 1]);
	}
	BF1::main();
	BF2::main();
	LL r = 0;
	for (int i = 1; i <= n; i++) r += (LL)d[i] * (n - d[i] - 1);
	r >>= 1;
	r += BF3::main();
	write((LL)n * (n - 1) * (n - 2) / 6 - r);
}
// I love WHQ!