#include <iostream>

 #include <cstdio>

 #include <string>

 #include <cstring>

 #include <algorithm>

 #include <cmath>

 #include <vector>

 #include <queue>

 #include <stack>

 #include <ctime>

 #define ll long long

 # define lson l,m,rt<<

 # define rson m+,r,rt<<|

 using namespace std;

 const int maxn = +;

 # define inf 0x3f3f3f3f

 struct node

 {

     int l,r,h;

     int d;

     node() {}

     node(int xx,int yy,int zz,int tt)

     {

         l=xx;

         r=yy;

         h=zz;

         d=tt;

     }

     bool friend operator < (node t1,node t2)

     {

         return t1.h<t2.h;

     }

 } q[maxn<<];

 int Hash[maxn];

 int tree[maxn],lazy[maxn],cnt[maxn];

 int lx[maxn],ly[maxn];

 void up(int l,int r,int rt)

 {

     if(lazy[rt])

     {

         cnt[rt]=;

         lx[rt]=;

         ly[rt]=;

         tree[rt]=Hash[r+]-Hash[l];

     }

     else if(l==r)

     {

         cnt[rt]=;

         tree[rt]=;

         lx[rt]=ly[rt]=;

     }

     else

     {

         cnt[rt]=cnt[rt<<]+cnt[rt<<|]-(lx[rt<<|]&ly[rt<<]);//这个地方注意是左边端点的右定点和右边端点的左定点，因为是需要判断区间是否有相交

         tree[rt]=tree[rt<<]+tree[rt<<|];

         lx[rt]=lx[rt<<],ly[rt]=ly[rt<<|];

     }

 }

 void update(int l,int r,int rt,int L,int R,int p)

 {

     if(L<=l&&R>=r)

     {

         lazy[rt]+=p;

         up(l,r,rt);

         return ;

     }

     int m=(l+r)>>;

     if(L<=m)

         update(lson,L,R,p);

     if(R>m)

         update(rson,L,R,p);

     up(l,r,rt);

 }

 int main()

 {

     int n;

     while(~scanf("%d",&n))

     {

         int num=;

         int x1,y1,x2,y2;

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

         {

             scanf("%d %d %d %d",&x1,&y1,&x2,&y2);

             q[num]= {x1,x2,y1,};

             Hash[num++]=x1;

             q[num]= {x1,x2,y2,-};

             Hash[num++]=x2;

         }

         sort(Hash,Hash+num);

         sort(q,q+num);

         int k=;

         for(int i=; i<num; i++)

         {

             if(Hash[i]==Hash[i-])

                 continue;

             Hash[k++]=Hash[i];

         }

         memset(cnt,,sizeof(cnt));

         memset(lx,,sizeof(lx));

         memset(ly,,sizeof(ly));

         memset(tree,,sizeof(tree));

         memset(lazy,,sizeof(lazy));

         int ans=;

         int len=;

         for(int i=; i<num; i++)

         {

             int l=lower_bound(Hash,Hash+k,q[i].l)-Hash;

             int r=lower_bound(Hash,Hash+k,q[i].r)-Hash-;

             update(,k-,,l,r,q[i].d);

             ans+=abs(len-tree[]);

               len=tree[];

             if(i<num-)

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

         }

         printf("%d\n",ans);

     }

     return ;

 }