#include<bits/stdc++.h>
using namespace std;
#define rep2(i,j,k) for(ll i=ll(j);i<ll(k);i++)
#define rep(i,k) rep2(i,0,k)
#define rrep2(i,j,k) for(ll i=ll(j)-1;i>=ll(k);i--)
#define rrep(i,j) rrep2(i,j,0)
#define SZ(a) ll(a.size())
#define eb emplace_back
#define all(a) a.begin(),a.end()
using ll=long long;
using vl=vector<ll>;
using vvl=vector<vl>;
using P=pair<ll,ll>;
using vp=vector<P>;
using vvp=vector<vp>;
const ll inf=LLONG_MAX/4;
template<class T>
bool chmin(T& a,T b){return a>b?a=b,1:0;}
template<class T>
bool chmax(T& a,T b){return a<b?a=b,1:0;}

using ld=long double;
const ld EPS=1e-12;

struct Pt3{
	ld x,y,z;
	Pt3(ld x=0,ld y=0,ld z=0):x(x),y(y),z(z){}
	ld dot(Pt3 p){return x*p.x+y*p.y+z*p.z;}
	Pt3 operator-(Pt3 p){return Pt3(x-p.x,y-p.y,z-p.z);}
	Pt3 operator+(Pt3 p){return Pt3(p.x+x,p.y+y,p.z+z);}
	Pt3 operator*(ld d){return Pt3(x*d,y*d,z*d);}
	Pt3 operator/(ld d){return Pt3(x/d,y/d,z/d);}
	Pt3 cross(Pt3 p){return Pt3(y*p.z-z*p.y,z*p.x-x*p.z,x*p.y-y*p.x);}
	Pt3 cross(Pt3 p,Pt3 q){return (p-*this).cross(q-*this);}
	ld dist2(){return dot(*this);}
	ld dist(){return sqrt(dist2());}
	Pt3 unit(){return *this/dist();}
};

Pt3 input(){
	ld x,y,z;cin>>x>>y>>z;
	return Pt3(x,y,z);
}

struct Plane{
	Pt3 a;
	ld b;
	Plane()=default;
	Plane(Pt3 p,Pt3 q,Pt3 r){
		a=p.cross(q,r);
		b=a.dot(p);
	}
};

struct Line{
	Pt3 a,b,ab;
	Line()=default;
	Line(Pt3 a,Pt3 b):a(a),b(b),ab(b-a){}
};

Pt3 cp(Plane p,Line l){
	return l.a+l.ab*(p.b-p.a.dot(l.a))/p.a.dot(l.ab);
}


using Pt=complex<ld>;
using vt=vector<Pt>;

Pt tr(Pt3 a,Pt3 b,Pt3 c,Pt3 p){
	Pt3 x=(b-a).unit();
	Pt3 y=(c-a).unit();
	return Pt(x.dot(p-a),y.dot(p-a));
}

#define r(a) real(a)
#define i(a) imag(a)
#define ln "\n"

bool equal(ld a,ld b){return abs(a-b)<=EPS;}
bool equal(Pt a,Pt b){return equal(r(a),r(b)) && equal(i(a),i(b));}
ld dot(Pt a,Pt b){return r(a)*r(b)+i(a)*i(b);}
ld cross(Pt a,Pt b){return r(a)*i(b)-i(a)*r(b);}
ld cross(Pt a,Pt b,Pt c){return cross(b-a,c-a);}

Pt cp(Pt a,Pt b,Pt p,Pt q){
	ld d1=cross(b-a,q-p);
	ld d2=cross(b-a,b-p);
	return p+(q-p)*d2/d1;
}


vt cut(vt v,Pt a,Pt b){
	vt res;
	auto out=[&](Pt p){return cross(a,b,p)<0;};
	ll n=SZ(v);
	rep(i,n){
		if(!out(v[i])) res.eb(v[i]);
		if(out(v[i])!=out(v[(i+1)%n])) res.eb(cp(a,b,v[i],v[(i+1)%n]));
	}
	return res;
}

struct line{
	Pt a,b,ab;
	line()=default;
	line(Pt a,Pt b):a(a),b(b),ab(b-a){}
	 bool operator < (line e) {
        auto type = [&](Pt p) {
            if (i(p) < -EPS || (equal(i(p), 0) && -EPS < r(p))) return -1;
            return 1;
        };
        int ta = type(ab), tb = type(e.ab);
        if (ta != tb) return (ta < tb);
        return cross(ab, e.ab) > EPS;
    }
    bool out(Pt r){
        return cross(ab, r-a) < -EPS;
    }
};


vt hp_intersect(vector<line> h) {
    sort(all(h));
    ll n = SZ(h), l = 0, r = -1;
    vector<line> dq(n + 5);
    auto bad = [&](line s, line t, line c){
        // One way; surely works for continuous values.
        return c.out(cp(s.a,s.b,t.a,t.b));
    };
    rep(i, n){
        while (l < r && bad(dq[r], dq[r-1], h[i])) r--;
        while (l < r && bad(dq[l], dq[l+1], h[i])) l++;
        if (l <= r && equal(cross(h[i].ab, dq[r].ab), 0)){
            if (dot(h[i].ab, dq[r].ab) < EPS) return {};
            if (cross(h[i].ab, dq[r].a-h[i].a) < -EPS) r--;
            else continue;
        }
        dq[++r] = h[i];
    }
    while (l+1 < r && bad(dq[r], dq[r-1], dq[l])) r--;
    while (l+1 < r && bad(dq[l], dq[l+1], dq[r])) l++;
    if (r-l < 2) return {};
	vt res(r-l+1);
	rep2(i,l,r) res[i-l] = cp(dq[i].a,dq[i].b,dq[i+1].a,dq[i+1].b);
	res[r-l] = cp(dq[l].a,dq[l].b,dq[r].a,dq[r].b);
	return res;
}

void solve(){
	vector<Pt3> a(4),b(4),c(4);
	rep(i,4) b[i]=input();
	rep(i,4) a[i]=input();
	rep(i,4){
		Plane p(a[0],a[1],a[2]);
		c[i]=cp(p,Line(Pt3(),b[i]));
	}
	vt p(4),q(4);
	rep(i,4){
		p[i]=tr(a[0],a[1],a[3],a[i]);
		q[i]=tr(a[0],a[1],a[3],c[i]);
	}
	{
		ld area=0;
		rep(i,4) area+=cross(q[i],q[(i+1)%4]);
		if(area<0) reverse(all(q));
	}
	vt v;
	{
		vector<line> hp;
		rep(i,4) hp.eb(line(p[i],p[(i+1)%4]));
		rep(i,4) hp.eb(line(q[i],q[(i+1)%4]));
		v=hp_intersect(hp);
	}
	ll n=SZ(v);
	ld left=0, right=1e9;
	auto cup=[&](ld x){
		ld l=inf, r=-inf;
		rep(i,n){
			Pt s=v[i],t=v[(i+1)%n];
			if(r(s)>r(t)) swap(s,t);
			if(r(t)<x-EPS || x+EPS<r(s)) continue;
			if(equal(r(s),r(t))){
					chmin(l,i(s));
					chmin(l,i(t));
					chmax(r,i(s));
					chmax(r,i(t));
			}
			else{
				Pt cand=(t*(x-r(s))+s*(r(t)-x))/(r(t)-r(s));
				chmin(l,i(cand));
				chmax(r,i(cand));
			}
		}
		return make_pair(l,r);
	};
	while(left+EPS<right){
		ld h=(left+right)/ld(2);
		ld w=h*(b[1]-b[0]).dist()/(b[3]-b[0]).dist();
		vector<ld> x(n*2);
		rep(i,n) x[i]=r(v[i]), x[i+n]=r(v[i])-w;
		sort(all(x));
		bool flag=false;
		rep(i,2*n-1){
			if(equal(x[i],x[i+1])) continue;		
			vector<line> cand;
			{
				ld l=x[i],r=x[i+1];
				auto ly=cup(l);
				auto ry=cup(r);
				if(ly.first-EPS<ly.second && ry.first-EPS<ry.second){
					cand.eb(Pt(l,ly.first),Pt(r,ry.first));
					cand.eb(Pt(l,ly.second),Pt(r,ry.second));
				}
			}
			{
				ld l=x[i],r=x[i+1];
				auto ly=cup(l+w);
				auto ry=cup(r+w);
				if(ly.first-EPS<ly.second && ry.first-EPS<ry.second){
					cand.eb(Pt(l,ly.first),Pt(r,ry.first));
					cand.eb(Pt(l,ly.second),Pt(r,ry.second));
				}
			}
			rep(j,SZ(cand)){
				rep(k,j){
					if(equal(cross(cand[j].ab,cand[k].ab),0)) continue;
					x.eb(r(cp(cand[j].a,cand[j].b,cand[k].a,cand[k].b)));
				}
			}
		}
		sort(all(x));
		rep(i,SZ(x)-1){
			ld l=x[i], r=x[i]+w;
			auto ly=cup(l), ry=cup(r);
			ld val = min(ry.second,ly.second)-max(ry.first,ly.first);
			if(val>=h) flag=true;
		}
		if(!flag) right=h;
		else left=h;
	}
	ld h=right;
	ld w=h*(b[1]-b[0]).dist()/(b[3]-b[0]).dist();
	cout<<h*w<<ln;
}

int main(){
	cin.tie(0)->sync_with_stdio(0);
	cout<<fixed<<setprecision(10);
	ll t;cin>>t;
	while(t--) solve();
}