#include <algorithm>

#include <bitset>

#include <cctype>

#include <cerrno>

#include <clocale>

#include <cmath>

#include <complex>

#include <cstdio>

#include <cstdlib>

#include <cstring>

#include <ctime>

#include <deque>

#include <exception>

#include <fstream>

#include <functional>

#include <limits>

#include <list>

#include <map>

#include <iomanip>

#include <ios>

#include <iosfwd>

#include <iostream>

#include <istream>

#include <ostream>

#include <queue>

#include <set>

#include <sstream>

#include <stdexcept>

#include <streambuf>

#include <string>

#include <utility>

#include <vector>

#include <cwchar>

#include <cwctype>

#include <stack>

#include <limits.h>

using namespace std;

#define MAXN 110

int i,n,l1,l2,l,L,R,TC;

double xa,ya,xb,yb,area;

double a[MAXN*],x[MAXN*],arr[MAXN*];

struct info {

        double l,r,h,opt;

} y[MAXN*];

struct SegmentTree {

        struct Node {

                int l,r,c;

                double m;

        } Tree[MAXN*];

        inline void build(int index,int l,int r) {

                int mid;

                Tree[index].l = l;

                Tree[index].r = r;

                Tree[index].m = 0.0;

                Tree[index].c = ;

                if (l == r) return;

                mid = (l + r) >> ;

                build(index<<,l,mid);

                build(index<<|,mid+,r);

        }

        inline void update(int index) {

                if (Tree[index].c > ) Tree[index].m = arr[Tree[index].r+] - arr[Tree[index].l];

                else if (Tree[index].l == Tree[index].r) Tree[index].m = ;

                else Tree[index].m = Tree[index<<].m + Tree[index<<|].m;

        }

        inline void add(int index,int l,int r,int val) {

                int mid;

                if (Tree[index].l == l && Tree[index].r == r) {

                        Tree[index].c += val;

                        update(index);

                        return;

                }

                mid = (Tree[index].l + Tree[index].r) >> ;

                if (mid >= r) add(index<<,l,r,val);

                else if (mid +  <= l) add(index<<|,l,r,val);

                else {

                        add(index<<,l,mid,val);

                        add(index<<|,mid+,r,val);

                }

                update(index);

        }

        inline double query() {

                return Tree[].m;

        }

} T;

bool cmp(info a,info b) { return a.h > b.h; }

int main() {

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

                l = l1 = l2 = ;

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

                        scanf("%lf%lf%lf%lf",&xa,&ya,&xb,&yb);

                        x[++l1] = xa;

                        x[++l1] = xb;

                        y[++l2] = (info){xa,xb,ya,-};

                        y[++l2] = (info){xa,xb,yb,};

                }

                sort(x+,x+l1+);

                x[] = -;

                for (i = ; i <= l1; i++) {

                        if (x[i] != x[i-])

                                arr[++l] = x[i];

                }

                T.build(,,l-);

                sort(y+,y+l2+,cmp);

                area = 0.0;

                for (i = ; i < l2; i++) {

                        L = lower_bound(arr+,arr+l+,y[i].l) - arr;

                        R = lower_bound(arr+,arr+l+,y[i].r) - arr - ;

                        T.add(,L,R,y[i].opt);

                        area += T.query() * (y[i].h - y[i+].h);

                }

                printf("Test case #%d\nTotal explored area: %.2f\n\n",++TC,area);

        }

        return ;

}