#include <iostream>

 #include <cstdio>

 #include <cstring>

 #include <cmath>

 #include <algorithm>

 #include <vector>

 #include <queue>

 #include <stack>

 #include <map>

 #include <string>

 #include <set>

 using namespace std;

 typedef long long LL;

 const double EPS = 1e-;

 const int INF = 2e9;

 const LL LNF = 2e18;

 const int MAXN = 1e5+;

 struct line

 {

     double le, ri, h;

     int id;

     bool operator<(const line &a)const{

         return h<a.h;

     }

 }Line[MAXN];

 int times[MAXN<<];

 double X[MAXN], one[MAXN], more[MAXN<<];

 //X用于离散化横坐标，times为此区间被覆盖的次数，

 //one为此区间被覆盖一次的长度和， more为此区间至少被覆盖两次的长度和

 void push_up(int u, int l, int r)

 {

     if(times[u]>=) //该区间被覆盖了两次

     {

         more[u] = X[r] - X[l];

         one[u] = X[r] - X[l];

     }

     else if(times[u]==)    //该区间被覆盖了一次

     {

         more[u] = one[u*]+one[u*+];

         one[u] = X[r] - X[l];

     }

     else //该区间没有被覆盖

     {

         if(l+==r) //该区间为单位区间

             more[u] = one[u] = ;

         else

         {

             more[u] = more[u*]+more[u*+];

             one[u] = one[u*]+one[u*+];

         }

     }

 }

 //此种线段树的操作对象为连续型，即最小的元素为长度为1的区间[l,r],其中l和r只代表端点(r-l>=1)，用于确定

 //区间的位置和长度，l和r本身没有特别的含义。而以往做的什么单点更新之类的，都属于离散型，在l处和r处是有含义的

 void add(int u, int l, int r, int x, int y, int val)

 {

     if(x<=l && r<=y)

     {

         times[u] += val;

         push_up(u, l, r);

         return;

     }

     int mid = (l+r)>>;

     if(x<=mid-) add(u*, l, mid, x, y, val);

     if(y>=mid+) add(u*+, mid, r, x, y, val);

     push_up(u, l, r);

 }

 int main()

 {

     int n, T;

     scanf("%d", &T);

     while(T--)

     {

         scanf("%d", &n);

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

         {

             double x1, y1, x2, y2;

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

             Line[i].le = Line[i+n].le = x1;

             Line[i].ri = Line[i+n].ri = x2;

             Line[i].h = y1; Line[i+n].h = y2;

             Line[i].id = ; Line[i+n].id = -;

             X[i] = x1; X[i+n] = x2;

         }

         sort(Line+, Line++*n);

         sort(X+, X++*n);

         int m = unique(X+, X++*n) - (X+);   //去重

         memset(more, , sizeof(more));

         memset(one, , sizeof(one));

         memset(times, , sizeof(times));

         double ans = ;

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

         {

             int l = upper_bound(X+, X++m, Line[i].le) - (X+);

             int r = upper_bound(X+, X++m, Line[i].ri) - (X+);

             add(, , m, l, r, Line[i].id);

             ans += more[]*(Line[i+].h-Line[i].h);

         }

         printf("%.2f\n", ans);

     }

 }