//ac F

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#include <iostream>

#include <algorithm>

using namespace std;

typedef long long ll;

const int maxn=1e6+;

#define mm(a) memset(a,0,sizeof(a))

int num1[maxn*];

int num[maxn*],X[maxn*];

struct edge

{

    int l,r,h;

    int s;//s为1是下边，s为-1是上边

    edge() {};

    edge(int a,int b,int c,int d) : l(a),r(b),h(c),s(d) {}

    bool operator<(const edge &n)const

    {

        return h<n.h;

    }

} ss[maxn];

void pushup(int le,int ri,int node)

{

    if(num1[node])

        num[node]=X[ri+]-X[le];//在更新的时候，可能两个矩阵有重叠，这样就不能像以前那么更新，而是将le和ri传入

    else if(le==ri)

        num[node]=;           //然后将X[ri+1]-X[le]的值进行更新，避免了重复的长度

    else

        num[node]=num[node<<]+num[node<<|];

}

void update(int l,int r,int add,int le,int ri,int node)

{

    if(l<=le&&ri<=r)

    {

        num1[node]+=add;//与懒惰标记类似

        pushup(le,ri,node);

        return ;

    }

    int t=(le+ri)>>;

    if(l<=t) update(l,r,add,le,t,node<<);

    if(r>t) update(l,r,add,t+,ri,node<<|);

    pushup(le,ri,node);

}

int main()

{

    int n;

    while(scanf("%d",&n) != EOF)

    {

        if(n == )

        {

            cout << "*" << endl;

            break;

        }

        int a,b,c,d;

        int k=;

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

        {

            scanf("%d%d%d%d",&a,&b,&c,&d);

            X[k]=a;

            ss[k++]=edge(a,c,b,);

            X[k]=c;

            ss[k++]=edge(a,c,d,-);

        }

        sort(X,X+k);

        sort(ss,ss+k);

        int k1=;

        for(int i=; i<k; i++) //对X进行离散化

        {

            if(X[i]!=X[i-]) X[k1++]=X[i];

        }

        mm(num);

        mm(num1);

        int ans=;

        for(int i=; i<k-; i++)

        {

            int l=lower_bound(X,X+k1,ss[i].l)-X;

            int r=lower_bound(X,X+k1,ss[i].r)-X-;

            update(l,r,ss[i].s,,k1-,);

            ans+=num[]*(ss[i+].h-ss[i].h);//num[1]为当前横坐标的总长度

        }

        cout << ans << endl;

    }

    return ;

}