#include <algorithm>

#include <bitset>

#include <cctype>

#include <cerrno>

#include <clocale>

#include <cmath>

#include <complex>

#include <cstdio>

#include <cstdlib>

#include <cstring>

#include <ctime>

#include <deque>

#include <exception>

#include <fstream>

#include <functional>

#include <limits>

#include <list>

#include <map>

#include <iomanip>

#include <ios>

#include <iosfwd>

#include <iostream>

#include <istream>

#include <ostream>

#include <queue>

#include <set>

#include <sstream>

#include <stdexcept>

#include <streambuf>

#include <string>

#include <utility>

#include <vector>

#include <cwchar>

#include <cwctype>

#include <stack>

#include <limits.h>

using namespace std;

#define MAXN 5010

 int i,L,R,l1,l2,ans,last,n,xa,xb,ya,yb;

 int x[MAXN*];

struct info {

        int l,r,h,opt;

} y[MAXN*];

struct Node {

        int l,r,sum,cnt,c;

        bool lc,rc;

} Tree[MAXN*];

bool cmp(info a,info b) { return a.h > b.h; }

template <typename T> inline void read(T &x) {

        int f = ; x = ;

        char c = getchar();

        for (; !isdigit(c); c = getchar()) { if (c == '-') f = -f; }

        for (; isdigit(c); c = getchar()) x = (x << ) + (x << ) + c - '';

        x *= f;

}

template <typename T> inline void write(T x) {

    if (x < ) { putchar('-'); x = -x; }

    if (x > ) write(x/);

    putchar(x%+'');

}

template <typename T> inline void writeln(T x)  {

    write(x);

    puts("");

}

inline void build(int index,int l,int r) {

        int mid;

        Tree[index].l = l;

        Tree[index].r = r;

        Tree[index].c = Tree[index].sum = Tree[index].cnt = ;

        Tree[index].lc = Tree[index].rc = false;

        if (l == r) return;

        mid = (l + r) >> ;

        build(index<<,l,mid);

        build(index<<|,mid+,r);

}

inline void push_up(int index) {

        if (Tree[index].c > ) {

                Tree[index].sum = x[Tree[index].r+] - x[Tree[index].l];

                Tree[index].cnt = ;

                Tree[index].lc = Tree[index].rc = true;

        } else if (Tree[index].l == Tree[index].r) {

                    Tree[index].sum = Tree[index].cnt = ;

                    Tree[index].lc = Tree[index].rc = false;

        } else {

                    Tree[index].lc = Tree[index<<].lc;

                    Tree[index].rc = Tree[index<<|].rc;

                    Tree[index].sum = Tree[index<<].sum + Tree[index<<|].sum;

                    Tree[index].cnt = Tree[index<<].cnt + Tree[index<<|].cnt;

                    if (Tree[index<<].rc && Tree[index<<|].lc) Tree[index].cnt--;

        }

}

inline void update(int index,int l,int r,int val) {

        int mid;

        if (Tree[index].l == l && Tree[index].r == r) {

                Tree[index].c += val;

                push_up(index);

                return;

        }

        mid = (Tree[index].l + Tree[index].r) >> ;

        if (mid >= r) update(index<<,l,r,val);

        else if (mid +  <= l) update(index<<|,l,r,val);

        else {

                update(index<<,l,mid,val);

                update(index<<|,mid+,r,val);

        }

        push_up(index);

}

int main() {

        scanf("%d",&n);

                l1 = l2 = ;

                for (i = ; i <= n; i++) {

                        read(xa); read(ya); read(xb); read(yb);

                        x[++l1] = xa;

                        x[++l1] = xb;

                        y[++l2] = (info){xa,xb,ya,-};

                        y[++l2] = (info){xa,xb,yb,};

                }

                l1 = unique(x+,x+l1+) - x;

                sort(x+,x+l1+);

                build(,,l1-);

                sort(y+,y+l2+,cmp);

                ans = last = ;

                for (i = ; i < l2; i++) {

                        L = lower_bound(x+,x+l1+,y[i].l) - x;

                        R = lower_bound(x+,x+l1+,y[i].r) - x - ;

                        update(,L,R,y[i].opt);

                        ans += Tree[].cnt *  * (y[i].h - y[i+].h);

                        ans += abs(Tree[].sum - last);

                        last = Tree[].sum;

                }

                L = lower_bound(x+,x+l1+,y[l2].l) - x;

                R = lower_bound(x+,x+l1+,y[l2].r) - x - ;

                update(,L,R,y[l2].opt);

                ans += abs(Tree[].sum - last);

                writeln(ans);

        return ;

}