#define mul_cases false

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <string>
#include <cctype>
#include <vector>
#include <cstring>
using namespace std;

typedef __int128 ll;
typedef __int128 lll;
typedef unsigned long long ull;

bool MEM1;

int read()
{
    int x = 0, f = 1;
    char ch = getchar();
    for (; !isdigit(ch); ch = getchar())
        if (ch == '-')
				f = -1;
    for (; isdigit(ch); ch = getchar())
        x = x * 10 + ch - '0';
    return x * f;
}

void write(lll x)
{
    if (x > 10)
        write(x / 10);
    putchar(x % 10 + '0');
}

namespace solve
{
    const int maxn = 4e5 + 10;
    struct point
    {
        int x, y;
    };
    struct poly
    {
        point a, b;
    } a[maxn];
    int n;
    ll deg[maxn];

    lll C3(int n)
    {
        if (n < 3)
            return 0;
        return lll(1) * n * (n - 1) / 2 * (n - 2) / 3;
    }

    struct line
    {
        int x;
        int y1, y2;
        int id, val;
        bool operator<(const line &b) const { return x < b.x; }
    } seg[maxn];
    int tot;
    ll ans[maxn];

#define int long long

    struct segtree
    {
        static const int maxn = solve::maxn << 2;
        lll x1[maxn], x2[maxn];
        lll x3[maxn];
        bool flag;
        lll lzy[maxn];

        inline int ls(int x) { return x * 2; }
        inline int rs(int x) { return x * 2 + 1; }

        inline void add(int x, int v, int l, int r)
        {
            int len = r - l + 1;
            lzy[x] += v;
            if (flag)
            {
                x3[x] += 3 * v * x2[x] + 3 * v * v * x1[x] + len * v * v * v;
                x2[x] += 2 * v * x1[x] + len * v * v;
            }
            x1[x] += len * v;
        }

        inline void push_up(int k)
        {
            x1[k] = x1[ls(k)] + x1[rs(k)];
            if (flag)
                x2[k] = x2[ls(k)] + x2[rs(k)], x3[k] = x3[ls(k)] + x3[rs(k)];
        }

        inline void push_down(int k, int l, int r, int mid)
        {
            if (!lzy[k])
                return;
            add(ls(k), lzy[k], l, mid), add(rs(k), lzy[k], mid + 1, r);
            lzy[k] = 0;
        }

        void modify(int l, int r, int x, int y, int v, int k)
        {
            if (x > y)
                return;
            if (l >= x && r <= y)
            {
                add(k, v, l, r);
                return;
            }
            int mid = (l + r) / 2;
            push_down(k, l, r, mid);
            if (x <= mid)
                modify(l, mid, x, y, v, ls(k));
            if (y > mid)
                modify(mid + 1, r, x, y, v, rs(k));
            push_up(k);
        }

        int query_num(int l, int r, int x, int k)
        {
            if (l == r)
                return x1[k];
            int mid = (l + r) / 2;
            push_down(k, l, r, mid);
            return x <= mid ? query_num(l, mid, x, ls(k)) : query_num(mid + 1, r, x, rs(k));
        }

        lll query_c()
        {
            int mid = (1 + 2 * n) / 2;
            push_down(1, 1, 2 * n, mid);
            return max(lll(0), (x3[1] - x2[1] * 3 + x1[1] * 2) / 6);
        }
        segtree() : flag(1) {}
        segtree(bool flag_) : flag(flag_) {}
    } pre(0), suf(0), pre2(0), suf2(0), t1, t2;

#undef int

    void main()
    {
        n = read();
        vector<int> allx, ally;
        for (int i = 1; i <= n; i++)
        {
            a[i].a.x = read(), a[i].b.x = read(), a[i].a.y = read(), a[i].b.y = read();
            allx.push_back(a[i].a.x), allx.push_back(a[i].b.x);
            ally.push_back(a[i].a.y), ally.push_back(a[i].b.y);
        }
        sort(allx.begin(), allx.end());
        sort(ally.begin(), ally.end());
        allx.erase(unique(allx.begin(), allx.end()), allx.end());
        ally.erase(unique(ally.begin(), ally.end()), ally.end());
        for (int i = 1; i <= n; i++)
            a[i].a.x = lower_bound(allx.begin(), allx.end(), a[i].a.x) - allx.begin() + 1,
            a[i].b.x = lower_bound(allx.begin(), allx.end(), a[i].b.x) - allx.begin() + 1,
            a[i].a.y = lower_bound(ally.begin(), ally.end(), a[i].a.y) - ally.begin() + 1,
            a[i].b.y = lower_bound(ally.begin(), ally.end(), a[i].b.y) - ally.begin() + 1;
        lll res1 = 0;
        // for (int i = 1; i <= n; i++)
        //     cout << a[i].a.x << " " << a[i].a.y << " " << a[i].b.x << " " << a[i].b.y << endl;
        for (int i = 1; i <= n; i++)
        {
            seg[++tot] = {a[i].a.x, a[i].a.y, a[i].b.y, i, 1};
            seg[++tot] = {a[i].b.x, a[i].a.y, a[i].b.y, i, -1};
        }
        sort(seg + 1, seg + 1 + tot);
        int now = 0, now2 = 0;
        for (int i = 1; i <= tot; i++)
        {
            if (seg[i].val == 1)
            {
                deg[seg[i].id] -= pre.query_num(1, n * 2, seg[i].y2, 1);
                deg[seg[i].id] -= suf.query_num(1, n * 2, seg[i].y1, 1);
                deg[seg[i].id] += now++;
                pre.modify(1, n * 2, 1, seg[i].y1 - 1, 1, 1);
                suf.modify(1, n * 2, seg[i].y2 + 1, n * 2, 1, 1);

                deg[seg[i].id] += pre2.query_num(1, n * 2, seg[i].y2, 1);
                deg[seg[i].id] += suf2.query_num(1, n * 2, seg[i].y1, 1);
                pre2.modify(1, n * 2, 1, seg[i].y1 - 1, 1, 1);
                suf2.modify(1, n * 2, seg[i].y2 + 1, n * 2, 1, 1);
                deg[seg[i].id] -= now2++;

                ans[seg[i].id] -= t1.query_c() - t2.query_c();
                // cerr << ans[seg[i].id] << endl;
                t1.modify(1, 2 * n, seg[i].y1, seg[i].y2, 1, 1);
                t2.modify(1, 2 * n, seg[i].y1, seg[i].y2 - 1, 1, 1);
                ans[seg[i].id] += t1.query_c() - t2.query_c();
            }
            else
            {
                pre.modify(1, n * 2, 1, seg[i].y1 - 1, -1, 1);
                suf.modify(1, n * 2, seg[i].y2 + 1, n * 2, -1, 1);
                now--;
                deg[seg[i].id] -= pre2.query_num(1, n * 2, seg[i].y2, 1);
                deg[seg[i].id] -= suf2.query_num(1, n * 2, seg[i].y1, 1);
                deg[seg[i].id] += now2 - 1;
                t1.modify(1, 2 * n, seg[i].y1, seg[i].y2, -1, 1);
                t2.modify(1, 2 * n, seg[i].y1, seg[i].y2 - 1, -1, 1);
            }
        }
        res1 = C3(n) * 2;
        for (int i = 1; i <= n; i++)
            res1 -= max(ll(0), 1ll * deg[i] * (n - 1 - deg[i]));
        res1 /= 2;
        for (int i = 1; i <= n; i++)
            res1 -= ans[i];
        cout << (long long)res1 << endl;
    }
}

bool MEM2;

signed main()
{
#ifdef local
    cerr << "memory : " << abs(&MEM1 - &MEM2) / 1024. / 1024 << " mb" << endl;
#endif

    int cases = 1;

    while (cases--)
        solve::main();

#ifdef local
    cerr << "time : " << 1000.0 * clock() / CLOCKS_PER_SEC << " ms" << endl;
#endif

    return 0;
}