#include<bits/stdc++.h>
using namespace std;

const int N=5e2+1e1+7;

const double eps=1e-6;

struct P {
    double x,y;
    P operator -(const P &s) const
    {
        return {x-s.x,y-s.y};
    }
    P operator +(const P &s) const
    {
        return {x+s.x,y+s.y};
    }

    double Len() const
    {
        return hypot(x,y);
    }

    double Len2() const
    {
        return x*x+y*y;
    }

    P Len(const double d) const 
    {
        return {x*d,y*d};
    }

    P operator *(const double d) const
    {
        return {x*d,y*d};
    }

    P operator /(const double d) const
    {
        return {x/d,y/d};
    }

    P unit() const 
    {
        return *this/Len();
    }

    P symmetry(const P &b) const
    {
        return b+b-*this;
    }
};

bool operator <(const P &a,const P &b)
{
    return a.y<b.y;
}

double dot(const P &a,const P &b)
{
    return a.x*b.x+a.y*b.y;
}

struct C {
    P o;
    double r;
    void rd()
    {
        int a,b,c;
        cin>>a>>b>>c;
        o.x=a,o.y=b,r=c;
    }
};

double sgn(double x)
{
    return x<-eps?-1:x>eps;
}

vector<P> circle_line_inter(P o,double r,P a,P b)
{
    P h=a+(b-a).unit()*dot(o-a,(b-a).unit());
    double t=r*r-(h-o).Len2();
    if(sgn(t)<0)
        return {};
    else if(!sgn(t))
        return {h,h};
    else
    {
        P p1=(a-b).Len(sqrt(t))+h;
        P p2=p1.symmetry(h);
        return {p1,p2};
    }
}

vector<pair<C,C> >cs;

double eval(double X)
{
    map<P,int>D;
    P u={X,1},v={X,0};
    for(auto [c,d]:cs)
    {
        auto pts=circle_line_inter(c.o,c.r,u,v);
        if(!pts.size())
            continue;
        auto a=pts[0],b=pts[1];
        if(b<a)
            swap(a,b);
        D[a]++;
        D[b]--;
        pts=circle_line_inter(d.o,d.r,u,v);
        if(pts.size())
        {
            auto e=pts[0],f=pts[1];
            if(f<e)
                swap(e,f);
            a.y=max(a.y,e.y);
            b.y=min(b.y,f.y);
            if(a.y<=b.y)
                D[a]--,D[b]++;
        }
    }
    if(!D.size())
        return 0;
    double ret=0;
    int S=0;
    for(auto it=D.begin();next(it)!=D.end();it++)
    {
        double dy=next(it)->first.y-it->first.y;
        S+=it->second;
        if(S>0)
        {
            ret+=dy;
        }
    }
    return ret;
}

double sim(double l,double r)
{
    return (eval(l)+eval(r)+4*eval((l+r)/2))*(r-l)/6;
}

double simp(double l,double r)
{
    // if(r-l<0.001)
    //     return 0;
    double mid=(l+r)/2;
    if(fabs(sim(l,r)-sim(l,mid)-sim(mid,r))<0.00001)
        return sim(l,mid)+sim(mid,r);
    return simp(l,mid)+simp(mid,r);
}

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    int T;
    cin>>T;
    while(T--)
    {
        int n;
        cin>>n;
        cs.clear();
        cs.resize(n);
        double mnX=1e18,mxX=0;
        for(auto &[c,d]:cs)
        {
            c.rd(),d.rd();
            mnX=min(mnX,c.o.x-c.r);
            mnX=min(mnX,d.o.x-d.r);
            mxX=max(mxX,c.o.x+c.r);
            mxX=max(mxX,d.o.x+d.r);
        }
        double LEN=mxX-mnX;
        double ans=0;
        const int F=10000;
        for(int i=0;i<F;i++)
        {
            double L=mnX+LEN*i/F,R=L+LEN/F;
            ans+=simp(L,R);
        }
        cout<<fixed<<setprecision(9)<<ans<<"\n";
    }
}