#include <stdio.h>

#include <algorithm>

#define LEN 10000

using namespace std;

struct Node

{

    int left;

    int right;

    int count;//被覆盖次数

    //所包含的区间数量，如三条[1,2]，[2,3]，[4,5]线段被覆盖，则line=2，因为 [1,2]，[2,3]是连续的。

    int line;//所包含的区间数量

    int lbd;//左端点是否被覆盖   用来辅助对line的计算

    int rbd;//右端点是否被覆盖

    int m;//测度  ，即覆盖的区间长度，如[2,8]就为6

}node[LEN*];;

struct ScanLine

{

    int x;

    int y1;

    int y2;

    int flag;

}scan[LEN];;

int y[LEN];

void build(int l, int r, int i)

{

    node[i].left = l;

    node[i].right = r;

    node[i].count = ;

    node[i].m = ;

    node[i].line = ;

    if (r - l > )

    {

        int middle = (l + r)/;

        build(l, middle, *i + );

        build(middle, r, *i + );

    }

}

//更新测度m

void update_m(int i)

{

    if (node[i].count > )

        node[i].m = y[node[i].right] - y[node[i].left];

    else if (node[i].right - node[i].left == )

        node[i].m = ;

    else

    {

        node[i].m = node[*i + ].m + node[*i + ].m;

    }

}

//更新line

void update_line(int i)

{

    if (node[i].count > )

    {

        node[i].lbd = ;

        node[i].rbd = ;

        node[i].line = ;

    }

    else if (node[i].right - node[i].left == )

    {

        node[i].lbd = ;

        node[i].rbd = ;

        node[i].line = ;

    }

    else

    {

        node[i].lbd = node[*i + ].lbd;

        node[i].rbd = node[*i + ].rbd;

        node[i].line = node[*i + ].line + node[*i + ].line - node[*i + ].rbd*node[*i + ].lbd;

    }

}

void insert(int l, int r, int i)

{

    //在这里要取离散化之前的原值进行比较

    if (y[node[i].left] >= l && y[node[i].right] <= r)

        (node[i].count)++;

    else if (node[i].right - node[i].left == )

        return;

    else

    {

        int middle = (node[i].left + node[i].right)/;

        if (r <= y[middle])

            insert(l, r, *i + );

        else if (l >= y[middle])

            insert(l, r, *i + );

        else

        {

            insert(l, y[middle], *i + );

            insert(y[middle], r, *i + );

        }

    }

    update_m(i);

    update_line(i);

}

void remove(int l, int r, int i)

{

    ////在这里要取离散化之前的原值进行比较

    if (y[node[i].left] >= l && y[node[i].right] <= r)

        (node[i].count)--;

    else if (node[i].right - node[i].left == )

        return;

    else

    {

        int middle = (node[i].left + node[i].right)/;

        if (r <= y[middle])

            remove(l, r, *i + );

        else if (l >= y[middle])

            remove(l, r, *i + );

        else

        {

            remove(l, y[middle], *i + );

            remove(y[middle], r, *i + );

        }

    }

    update_m(i);

    update_line(i);

}

bool cmp(ScanLine line1,ScanLine line2)

{

    if (line1.x == line2.x)

        return line1.flag > line2.flag;

    return (line1.x < line2.x);

}

int main()

{

    int n;

    scanf("%d", &n);

    int x1, y1, x2, y2;

    int i = ;

    while (n--)

    {

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

        scan[i].x = x1;

        scan[i].y1 = y1;

        scan[i].y2 = y2;

        scan[i].flag = ;

        y[i++] = y1;

        scan[i].x = x2;

        scan[i].y1 = y1;

        scan[i].y2 = y2;

        scan[i].flag = ;

        y[i++] = y2;

    }

    sort(y, y + i);

    sort(scan, scan + i, cmp);

    //y数组中不重复的个数

    int unique_count = unique(y, y + i) - y;

    //离散化，建立线段树

    build(, unique_count - , );

    int perimeter = ;

    int now_m = ;

    int now_line = ;

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

    {

        if (scan[j].flag)

            insert(scan[j].y1, scan[j].y2, );

        else

            remove(scan[j].y1, scan[j].y2, );

        if (j >= )

            perimeter += *now_line*(scan[j].x - scan[j-].x);

        //要减去，因为一个边只能算一次，要减去上一次已经算过的边

        perimeter += abs(node[].m - now_m);

        now_m = node[].m;

        now_line = node[].line;

    }

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

    return ;

}