hdu 1255

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <vector>
#include <map>
#include <set>
#include <string>
#include <cstring>
#include <list>
#include <queue>
#include <stack>
#include <cmath>

using namespace std;

#define PF(x) (scanf("%d",&x))
#define PT(x,y) (scanf("%d%d",&x,&y))
#define PR(x) (printf("%d\n",x))
#define PRT(x,y)(printf("%d %d\n",x,y))
#define PB(x)(scanf("%I64d",&x))
#define PRB(x)(printf("%I64d\n",(x)))
#define For(i,n) for(int i=0;i<(n);i++)
#define CLR(ar) (memset(ar,0,sizeof(ar)))
#define CLR1(ar) (memset(ar,-1,sizeof(ar)))
#define PBE(x) (scanf("%I64d",&x)!=EOF)
#define PLF(x,y) (scanf("%lf%lf",&x,&y))
#define Max(x,y) (x)>(y)?(x):(y)
#define Min(x,y) (x)>(y)?(y):(x)
#define L(x) (x<<1)
#define R(x) ((x<<1)|1)
#define Mid(x,y) ((x+y)>>1)
#define eps 1e-8

typedef __int64 LL;
#define N 200005
#define M 105
#define Mod 1000
#define Inf 0x7fffffff

double ar[N];
double sorted[N];

struct tree
{
	int l,r;
	int flag;
	double sl;
	double tl;
	double len()
	{
		return ar[r]-ar[l];
	}
};
tree T[4*N];

double equals(double s,double t)
{
	if(fabs(s-t)<eps) return true;
	return false;
}

void build(int l,int r,int k)
{
	T[k].l = l;
	T[k].r = r;
	T[k].flag = 0;
	T[k].sl = 0;T[k].tl=0;
	if(l+1 == r) return ;
	int mid = Mid(l,r);
	build(l,mid,L(k));
	build(mid,r,R(k));
}

void adjust(int node)
{
	
	if(T[node].flag ==0){
		if(T[node].l + 1 == T[node].r ) {T[node].sl = T[node].tl = 0;return ;}

		T[node].sl = T[L(node)].sl + T[R(node)].sl;
		T[node].tl = T[L(node)].tl + T[R(node)].tl;}
	else if(T[node].flag==1)
	{
		T[node].tl =  T[L(node)].sl + T[R(node)].sl+ T[L(node)].tl + T[R(node)].tl;
		T[node].sl = ar[T[node].r] - ar[T[node].l] - T[node].tl;
	}
	else 
	{
		T[node].sl = 0;
		T[node].tl = ar[T[node].r] - ar[T[node].l];
	}

}
void update(int l,int r,int k,int var)
{
	
	if(T[k].l == l &&T[k].r == r)
	{
		T[k].flag += var;
		adjust(k);
		return ;
	}

	int mid = Mid(T[k].l,T[k].r);
	if(r<=mid) update(l,r,L(k),var);
	else if(l>=mid) update(l,r,R(k),var);
	else {update(l,mid,L(k),var);update(mid,r,R(k),var);}
	
	adjust(k);
}

struct P
{
	double x,y;
	double xx,yy;
	int flag;
	void in(int i)
	{
		PLF(x,y);
		sorted[i] = y;
		if(i%2) flag =1;
		else flag = 0;
	}
	void exchang(P a)
	{
		xx = a.x;
		yy = a.y;
	}
};

P arr[N];
int n;
int tos;
double areas ;


int cmp(double a,double b)
{
	return a<b;
}

int recmp(const P &a,const P &b)
{
	if(equals(a.x,b.x)) return a.y<b.y;
	return a.x<b.x;
}

bool readata()
{
	PF(n);
	if(n==0) return false;
	
	areas = 0;

	For(i,2*n) 
	{
		arr[i].in(i);
		if(i%2) 
		{   
			arr[i-1].exchang(arr[i]);arr[i].exchang(arr[i-1]);
		
		}
	}

	sort(sorted,sorted+2*n,cmp);
    tos = 0;
	For(i,2*n)
	{
		if(i==0) sorted[tos++]= sorted[i],ar[tos] = sorted[i];
		else if(!equals(sorted[i],sorted[tos-1]))
			sorted[tos++] = sorted[i],ar[tos] = sorted[i];
	}

	sort(arr,arr+2*n,recmp);
	return true;
}
int searchs(double var)
{
	int l = 1,r=tos;
	while(l<=r)
	{
		int mid = Mid(l,r);
		if(equals(ar[mid],var)) return mid;
		if(var<ar[mid]) r = mid-1;
		else l = mid+1;
	}
	return l;
}
void solve()
{
	build(1,tos,1);
	double cur=arr[0].x;
	update(searchs(arr[0].y),searchs(arr[0].yy),1,1);

	for(int i=1;i<2*n;i++)
	{
		double now = arr[i].x;
        double len = T[1].tl;

		areas += (now-cur)*len;
		if(arr[i].flag)
		{
			update(searchs(arr[i].yy),searchs(arr[i].y),1,-1);
		}
		else update(searchs(arr[i].y),searchs(arr[i].yy),1,1);
		cur = now;
	}

}
void init()
{
	int test=1;
	PF(test);
	while(test--)
	{
		readata();
		solve();
		printf("%.2lf\n",areas);
	}
	return ;
}

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