# include <bits/stdc++.h>
using namespace std;
using i64 = long long; 
const int N = 4e5 + 5; 
struct node
{
    int l, r, id; 
    node () {}
    node (int x, int y, int w) : l(x), r(y), id(w) {}
}; 
int n, b[N << 1], c[N << 2], L, Lc, deg[N], Ans[N]; 
vector <node> Add[N], Del[N]; 
vector <tuple <int, int, int, int> > Qu; 

i64 C(int n, int m)
{
    if(m == 0) return 1ll;
    else if(m == 1) return n; 
    else if(m == 2) return n * (n - 1ll) / 2; 
    else if(m == 3) return n * (n - 1ll) * (n - 2ll) / 6ll; 
}

struct SgT
{
    struct node
    {
        i64 val[4], tag; 
    }T[N << 4];
    void build(int root, int l, int r)
    {
        T[root].val[0] = r - l + 1; 
        T[root].val[1] = T[root].val[2] = T[root].val[3] = T[root].tag = 0; 
        if(l == r) return; 
        int mid = (l + r) >> 1; 
        build(root << 1, l, mid), build(root << 1 | 1, mid + 1, r); 
        return; 
    }

    void pushtag(int root, i64 tag)
    {
        i64 tmp[4] = {0, 0, 0, 0}; 
        for(int p = 0; p <= 3; p++)
        {
            for(int x = 3; x >= p; x--) tmp[x] += C(tag, p) * T[root].val[x - p]; 
        }
        for(int x = 0; x <= 3; x++) T[root].val[x] = tmp[x]; 
        return; 
    }

    void pushup(int root) 
    {
        for(int x = 0; x <= 3; x++) 
            T[root].val[x] = T[root << 1].val[x] + T[root << 1 | 1].val[x]; 
        return; 
    }

    void pushdown(int root)
    {
        if(T[root].tag == 0) return;
        i64 tag = T[root].tag; T[root].tag = 0; 
        pushtag(root << 1, tag), pushtag(root << 1 | 1, tag); 
        T[root << 1].tag += tag, T[root << 1 | 1].tag += tag; 
        return; 
    }

    void update(int root, int l, int r, int s, int t, i64 d)
    {
        if(l > r || s > t) return; 
        if(l <= s && t <= r)
        {
            pushtag(root, d); T[root].tag += d; 
            return; 
        }
        pushdown(root); 
        int mid = (s + t) >> 1; 
        if(l <= mid) update(root << 1, l, r, s, mid, d); 
        if(r > mid) update(root << 1 | 1, l, r, mid + 1, t, d); 
        pushup(root); 
        return; 
    }

}Tv, Tvp; 

struct BIT
{
    int c[N << 2], lim = 0; 
    int lowbit(int x) {return x & (-x); } 
    void add(int x, int d)
    {
        while(x <= lim) c[x] += d, x += lowbit(x); 
        return; 
    }
    int query(int x) 
    {
        int ans = 0; 
        while(x) ans += c[x], x -= lowbit(x); 
        return ans; 
    }
    int Query(int l, int r)
    {
        if(l > r) return 0; 
        return query(r) - query(l - 1);  
    }
}Tl, Tr, Tpl, Tpr; 

int main(void)
{
    scanf("%d", &n); 
    for(int i = 1; i <= n; i++)
    {
        int l, r, d, u; scanf("%d%d%d%d", &l, &r, &d, &u);  b[++L] = l, b[++L] = r; 
        Qu.emplace_back(l, r, d, u); 
        c[++Lc] = d, c[++Lc] = u, c[++Lc] = u - 1; 
        // g[l].push_back({d, u, 1}), g[r].push_back({d, u, -1}); 
    }
    sort(b + 1, b + L + 1); sort(c + 1, c + Lc + 1); 
    L = unique(b + 1, b + L + 1) - b - 1; Lc = unique(c + 1, c + Lc + 1) - c - 1; 
    for(int i = 0; i < n; i++)
    {
        auto &[l, r, d, u] = Qu[i]; 
        l = lower_bound(b + 1, b + L + 1, l) - b; 
        r = lower_bound(b + 1, b + L + 1, r) - b; 
        d = lower_bound(c + 1, c + Lc + 1, d) - c; 
        u = lower_bound(c + 1, c + Lc + 1, u) - c; 
        Add[l].emplace_back(d, u, i), Del[r].emplace_back(d, u, i); 
        // printf("l = %d, r = %d, d = %d, u = %d\n", l, r, d, u); 
    }

    Tl.lim = Tr.lim = Tpl.lim = Tpr.lim = Lc; 
    int cnt1 = 0, cnt2 = 0; 
    for(int i = 1; i <= L; i++)
    {
        for(auto [l, r, id] : Add[i])
        {
            deg[id] = cnt1 - (Tr.Query(1, l - 1) + Tl.Query(r + 1, Lc)); 
            Ans[id] = cnt2 - (Tpr.Query(1, l - 1) + Tpl.Query(r + 1, Lc)); 
            Tl.add(l, 1), Tr.add(r, 1); Tpl.add(l, 1), Tpr.add(r, 1); 
            ++cnt1, ++cnt2; 
        }
        for(auto [l, r, id] : Del[i])
        {
            Tl.add(l, -1), Tr.add(r, -1); --cnt1; 
            deg[id] += (cnt2 - 1 - Tpr.Query(1, l - 1) - Tpl.Query(r + 1, Lc) - Ans[id]); 
            // printf("l = %d, r = %d, id = %d, Ans = %d, cont = %d\n", l, r, id, Ans[id], Tpr.Query(1, l - 1) + Tpl.Query(r + 1, Lc)); 
        }
    }
    i64 c0 = 0; 
    for(int i = 0; i < n; i++) 
    {
        c0 += 1ll * deg[i] * (n - deg[i] - 1ll);
        // printf("deg[%d] = %d\n", i, deg[i]); 
    }  
    c0 /= 2; 
    i64 c3 = 0; 
    Tv.build(1, 1, Lc), Tvp.build(1, 1, Lc); 
    for(int i = 1; i <= L; i++)
    {
        for(auto [l, r, tag] : Add[i])
        {
            i64 bef = Tv.T[1].val[3] - Tvp.T[1].val[3]; 
            Tv.update(1, l, r, 1, Lc, 1); 
            Tvp.update(1, l, r - 1, 1, Lc, 1);
            i64 now = Tv.T[1].val[3] - Tvp.T[1].val[3]; 
            c3 += (now - bef); 
        }
        for(auto [l, r, tag] : Del[i]) 
        {
            Tv.update(1, l, r, 1, Lc, -1); 
            Tvp.update(1, l, r - 1, 1, Lc, -1); 
        }
    }
    // printf("c0 = %lld, c3 = %lld\n", c0, c3); 
    printf("%lld\n", C(n, 3) - c0 - c3); 
    return 0; 
}