#include<stdio.h>

 #include<iostream>

 #include<stdlib.h>

 #include<string.h>

 #include<algorithm>

 #include<vector>

 #include<math.h>

 #include<map>

 #pragma comment(linker, "/STACK:1024000000,1024000000")

 using namespace std;

 #define maxn 1100

 #define mem(a,b) (memset(a),b,sizeof(a))

 #define lmin 1

 #define rmax len

 #define lson l,(l+r)/2,rt<<1

 #define rson (l+r)/2+1,r,rt<<1|1

 #define root lmin,rmax,1

 #define now l,r,rt

 #define int_now int l,int r,int rt

 #define INF 99999999

 #define LL long long

 #define mod 10007

 #define eps 1e-6

 #define zero(x) (fabs(x)<eps?0:x)

 #define LL __int64

 map<int,int>mp;

 int du[maxn*];

 struct lines

 {

     int x;

     int y,yy;

     int z,zz;

     int leap;

     friend bool operator <(const lines &a,const lines &b)

     {

         return a.x<b.x;

     }

 } line[maxn*];

 int num[maxn**];

 int sum[maxn**];

 int kum[maxn**];

 int cover[maxn**];

 void push_down(int_now)

 {

 }

 void push_up(int_now)

 {

     int len=du[r+]-du[l];

     if(cover[rt]==)

     {

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

         sum[rt]=sum[rt<<]+sum[rt<<|];

         kum[rt]=kum[rt<<]+kum[rt<<|];

     }

     if(cover[rt]==)

     {

         num[rt]=len;

         sum[rt]=num[rt<<]+num[rt<<|];

         kum[rt]=sum[rt<<]+sum[rt<<|];

     }

     if(cover[rt]==)

     {

         num[rt]=len;

         sum[rt]=len;

         kum[rt]=num[rt<<]+num[rt<<|];

     }

     if(cover[rt]>=)

     {

         num[rt]=len;

         sum[rt]=len;

         kum[rt]=len;

     }

 }

 void creat()

 {

     memset(cover,,sizeof(cover));

     memset(num,,sizeof(num));

     memset(sum,,sizeof(sum));

     memset(kum,,sizeof(kum));

 }

 void updata(int ll,int rr,int x,int_now)

 {

     if(ll>r||rr<l)return;

     if(ll<=l&&rr>=r)

     {

         cover[rt]+=x;

         push_up(now);

         return;

     }

     updata(ll,rr,x,lson);

     updata(ll,rr,x,rson);

     push_up(now);

 }

 int main()

 {

     int T,cas;

     scanf("%d",&T);

     cas=;

     while(T--)

     {

         cas++;

         int n,x,y,z,xx,yy,zz;

         mp.clear();

         scanf("%d",&n);

         LL ls=;

         du[]=-;

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

         {

             scanf("%d%d%d%d%d%d",&x,&y,&z,&xx,&yy,&zz);

             line[i*-].x=x;

             line[i*-].y=y;

             line[i*-].yy=yy;

             line[i*-].z=z;

             line[i*-].zz=zz;

             line[i*-].leap=;

             line[i*].x=xx;

             line[i*].y=y;

             line[i*].yy=yy;

             line[i*].z=z;

             line[i*].zz=zz;

             line[i*].leap=-;

             du[ls++]=y;

             du[ls++]=yy;

         }

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

         sort(du+,du+ls);

         int len=;

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

         {

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

             {

                 mp[du[i]]=len;

                 du[len++]=du[i];

             }

         }

         len-=;

         LL are=;

         int st=;

         creat();

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

         {

             st=;

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

             {

                 int l,r;

                 l=mp[line[i].y];

                 r=mp[line[i].yy];

                 if(line[i].z>j||line[i].zz<=j)continue;

                 LL x,y;

                 x=(LL)kum[];

                 y=(LL)line[i].x-st;

                 are+=x*y;

                 updata(l,r-,line[i].leap,root);

                 st=line[i].x;

             }

         }

         printf("Case %d: %I64d\n",cas,are);

     }

     return ;

 }