#include <cstdio>
#include <algorithm>
#include <iostream>
#include <cstdlib>
#include <cstring>

#define lc(x) (x << 1)
#define rc(x) (x << 1 | 1)
using namespace std;
const int inf = 0x3fffffff;
typedef long long LL;
const int N = 100100;
struct SegmentTree{
    int cov, sum;
    int ll, rr, cnt;
}T[N << 2];

struct Lin{
    int x, y1, y2, d;
    bool operator < (const Lin & a) const{
        if(x == a.x) return d > a.d;
        return x < a.x;
    }
}l[N << 1];

int ax[N << 1], ay[N << 1];
int xlen, ylen, lcnt;

void Build(int x, int l, int r){
    T[x].sum = T[x].ll = T[x].rr = T[x].cnt = 0;
    if(l == r) return;
    int mid = l + r >> 1;
    Build(lc(x), l, mid);
    Build(rc(x), mid + 1, r);
    return;
}

void Update(int x, int l, int r){
    if(T[x].cov){
        T[x].ll = T[x].rr = 1;
        T[x].cnt = 1;
        T[x].sum = ay[r + 1] - ay[l];
        return;
    }
    else if(l == r) T[x].ll = T[x].rr = T[x].sum = T[x].cnt = 0;
    else{
        T[x].rr = T[rc(x)].rr;
        T[x].ll = T[lc(x)].ll;
        T[x].sum = T[lc(x)].sum + T[rc(x)].sum;
        T[x].cnt = T[lc(x)].cnt + T[rc(x)].cnt - (T[rc(x)].ll && T[lc(x)].rr);
    }
    return;
}

void Modify(int x, int l, int r, int L, int R, int d){
    if(L <= l && r <= R){
        T[x].cov += d;
        Update(x, l, r);
        return;
    }
    int mid = l + r >> 1;
    if(L <= mid) Modify(lc(x), l, mid, L, R, d);
    if(R > mid) Modify(rc(x), mid + 1, r, L, R, d);
    Update(x, l, r);
    return;
}

void Disc(int *a, int &n){
    int nn = 1;
    sort(a + 1, a + n + 1);
    for(int i = 2; i <= n; i ++)
        if(a[i] != a[i - 1]) a[++ nn] = a[i];
    n = nn;
    return;
}

int n;

LL Abs(LL x){
    if(x < 0) return -x;
    return x; 
}

void Solve(){
    xlen = 0;
    ylen = 0;
    lcnt = 0;
    scanf("%d", &n);
    int x1, y1, x2, y2;
    for(int i = 1; i <= n; i ++){
        scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
        l[++ lcnt] = (Lin) {x1, y1, y2, 1};
        l[++ lcnt] = (Lin) {x2, y1, y2, -1};
        ax[++ xlen] = x1;
        ay[++ ylen] = y1;
        ax[++ xlen] = x2;
        ay[++ ylen] = y2;        
    }
    
    Disc(ax, xlen);
    Disc(ay, ylen);
    Build(1, 1, ylen - 1);
    
    for(int i = 1; i <= lcnt; i ++){
        l[i].x = lower_bound(ax + 1, ax + xlen + 1, l[i].x) - ax;
        l[i].y1 = lower_bound(ay + 1, ay + ylen + 1, l[i].y1) - ay;
        l[i].y2 = lower_bound(ay + 1, ay + ylen + 1, l[i].y2) - ay;
    }
    
    sort(l + 1, l + lcnt + 1);
    int j = 1;
    LL ans = 0, lastans = 0;
    
    for(int i = 1; i <= lcnt; i ++){
        Modify(1, 1, ylen - 1, l[i].y1, l[i].y2 - 1, l[i].d);
        ans += abs(T[1].sum - lastans) + 2 * T[1].cnt * (ax[l[i + 1].x] - ax[l[i].x]);
        lastans = T[1].sum;
    }
    
    printf("%lld\n", ans);
    
    return;
}

int main(){
    Solve();
    return 0;
}