#include<bits/stdc++.h>
using namespace std;
#ifdef DEBUG
#include"debug.h"
#else
#define debug(...) void()
#endif
#define all(x) (x).begin(),(x).end()
template<class T>
auto ary(T *a,int l,int r){
	return vector<T>{a+l,a+1+r};
}
using ll=long long;
using ull=unsigned long long;
using ld=long double;
using vec=complex<ld>;
const ld eps=1e-12;
ld dot(const vec &a,const vec &b){
	return real(a)*real(b)+imag(a)*imag(b);
}
ld cross(const vec &a,const vec &b){
	return dot(a,b*vec(0,-1));
}
ld dis2(const vec &a){
	return dot(a,a);
}
int sign(ld x){
	return (x>eps?1:(x<-eps?-1:0));
}
int T,xl,xr,yl,yr;
vec a[2],b[2];
void read(vec &a){
	int x,y;
	scanf("%d%d",&x,&y);
	a=vec(x,y);
}
vector<vec> common(vec a,vec b,vec x,vec y){
	ld s=cross(x-a,y-a),t=cross(y-b,x-b);
	if(sign(s+t)==0)return {};
	return {a*(t/(s+t))+b*(s/(s+t))};
}
vec arg(vec a){
	return a/abs(a);
}
pair<vec,vec> midline(vec a,vec b){
	return make_pair((a+b)/ld(2),arg(b-a)*vec(0,1));
}
bool chkin(vec x){
	return
		sign(real(x)-xl)>0&&sign(real(x)-xr)<0&&
		sign(imag(x)-yl)>0&&sign(imag(x)-yr)<0;
}
vec bnd[4];
ld calc1(vec st,vec arg){
	if(!chkin(st))return 0;
	ld len=INFINITY;
	for(int i=0;i<4;i++){
		for(vec x:common(bnd[i],bnd[(i+1)%4],st,st+arg)){
			if(sign(dot(x-st,arg))>=0)len=min(len,abs(x-st));
		}
	}
	return len;
}
ld calc2(vec a,vec b,vec arg){
	return abs(calc1(a,arg)-calc1(b,arg));
}
ld calc(ld d,ld a){
	ld w=sqrtl(a*a+4*d*d);
	return w*a/4/d+d*log(a+w);
}
vector<ld> solve(ld a,ld b,ld c){
	if(sign(a)==0){
		if(sign(b)==0)return {};
		else return {-c/b};
	}
	ld delta=b*b-4*a*c;
	if(sign(delta)<0)return {};
	delta=sqrtl(max<ld>(0,delta));
	return {(-b-delta)/2/a,(-b+delta)/2/a};
}
ld calc3(vec p1,vec p2,vec o,vec L,vec R){
	vec x=arg(p2-p1),y=x*vec(0,1);
	if(sign(dot(y,o-p1))<0)y=-y;
	ld d=dot(o-p1,y)/2,l=dot(L-o,x),r=dot(R-o,x);
	// debug(p1,p2,o,L,R,l,r);
	auto find=[&](ld p){
		return p*x+p*p/4/d*y+o-y*d;
	};
	if(l>r)swap(l,r),swap(L,R);
	vector<ld>t{l,r};
	for(int xt:{xl,xr}){
		for(ld p:solve(ld(1)/4/d*real(y),real(x),real(o-y*d)-xt)){
			if(sign(p-l)>0&&sign(p-r)<0)t.push_back(p);
		}
	}
	for(int yt:{yl,yr}){
		for(ld p:solve(ld(1)/4/d*imag(y),imag(x),imag(o-y*d)-yt)){
			if(sign(p-l)>0&&sign(p-r)<0)t.push_back(p);
		}
	}
	sort(all(t));
	// debug(t.size());
	ld res=0;
	for(int i=1;i<t.size();i++){
		ld tl=t[i-1],tr=t[i],mid=(tl+tr)/2;
		if(chkin(find(mid)))res+=abs(calc(d,tr)-calc(d,tl));
	}
	return res;
}
ld ans;
vec Common(vec a0,vec a1,vec b0,vec b1){
	vec i=arg((a1-a0)*vec(0,1)),j=arg((b1-b0)*vec(0,1));
	return (i+j)*(dot(i,a0)+dot(j,b0))/dis2(i+j);
}
void solve0(){
	vec mid=b[0]-cross(a[1]-a[0],b[0]-a[0])/abs(a[1]-a[0])/ld(2)*(arg(a[1]-a[0])*vec(0,1));
	auto solve=[&](vec a0,vec a1){
		vec o=Common(a0,a1,b[0],b[1]);
		vec half=arg(arg(a1-a0)+arg(b[1]-b[0])),las=mid;
		vec c0=common(o,o+half,b[0],b[0]+(b[1]-b[0])*vec(0,1))[0];
		auto [u0,u1]=midline(a1,b[0]);
		if(dot(u1,a1-a0)<0)u1=-u1;
		vec c1=common(u0,u0+u1,a1,a1+(a0-a1)*vec(0,1))[0];
		if(dot(c1-c0,a1-a0)>0){
			ans+=calc3(a0,a1,b[0],las,c0),las=c0;
			c0=common(o,o+half,b[1],b[1]+(b[0]-b[1])*vec(0,1))[0];
			c1=common(o,o+half,a1,a1+(a0-a1)*vec(0,1))[0];
			auto [v0,v1]=midline(a1,b[1]);
			if(dot(v1,a1-a0)<0)v1=-v1;
			if(dot(c1-c0,a1-a0)>0){
				ans+=calc2(las,c0,half),las=c0;
				c0=common(v0,v0+v1,a1,a1+(a0-a1)*vec(0,1))[0];
				ans+=calc3(a0,a1,b[1],las,c0),las=c0;
				ans+=calc1(las,v1);
			}else{
				ans+=calc2(las,c1,half),las=c1;
				c0=common(v0,v0+v1,b[1],b[1]+(b[0]-b[1])*vec(0,1))[0];
				ans+=calc3(b[0],b[1],a1,las,c0),las=c0;
				ans+=calc1(las,v1);
			}
		}else{
			ans+=calc3(a0,a1,b[0],las,c1),las=c1;
			if(sign(dot(b[1]-b[0],u1))<=0){
				ans+=calc1(las,u1);
			}else{
				c0=common(u0,u0+u1,b[0],b[0]+(b[1]-b[0])*vec(0,1))[0];
				ans+=calc2(las,c0,u1),las=c0;
				auto [v0,v1]=midline(a1,b[1]);
				if(dot(v1,a1-a0)<0)v1=-v1;
				c0=common(v0,v0+v1,b[1],b[1]+(b[0]-b[1])*vec(0,1))[0];
				ans+=calc3(b[0],b[1],a1,b[0],b[1]),las=c0;
				ans+=calc1(las,v1);
			}
		}
	};
	solve(a[0],a[1]);
	solve(a[1],a[0]);
}
void solve1(){
	vec mid=(a[0]+b[0])/ld(2);
	auto solve=[&](vec u){
		vec las=mid,a0=a[0],a1=a[1],b0=b[0],b1=b[1],c0,c1;
		int o0=sign(dot(a1-a0,u))>0,o1=sign(dot(b1-b0,u))>0;
		if(o0)c0=common(las,las+u,a0,a0+(a1-a0)*vec(0,1))[0];
		if(o1)c1=common(las,las+u,b0,b0+(b1-b0)*vec(0,1))[0];
		if(o0<o1||(o0==o1&&dot(c0-c1,u)>0))swap(o0,o1),swap(c0,c1),swap(a0,b0),swap(a1,b1);
		if(!o0)return ans+=calc1(las,u),void();
		ans+=calc2(las,c0,u),las=c0;
		auto [v0,v1]=midline(a1,b0);
		if(dot(v1,a1-a0)<0)v1=-v1;
		c0=common(v0,v0+v1,a1,a1+(a0-a1)*vec(0,1))[0],o0=1;
		vec o,half;
		if(sign(cross(b0-a0,a1-a0))==sign(cross(b1-b0,a1-a0))){
			o=Common(a0,a1,b0,b1),half=arg(arg(a1-a0)+arg(b1-b0));
			c1=common(o,o+half,b0,b0+(b1-b0)*vec(0,1))[0],o1=1;
		}else o1=0;
		if(o0>o1||(o0==o1&&dot(c1-c0,a1-a0)>0)){
			ans+=calc3(a0,a1,b0,las,c0),las=c0;
			if(!o1||sign(dot(v1,b1-b0))<=0){
				ans+=calc1(las,v1);
			}else{
				c0=common(v0,v0+v1,b0,b0+(b1-b0)*vec(0,1))[0];
				ans+=calc2(las,c0,v1),las=c0;
				auto [w0,w1]=midline(a1,b1);
				if(dot(w1,b1-b0)<0)w1=-w1;
				c0=common(w0,w0+w1,b1,b1+(b0-b1)*vec(0,1))[0];
				ans+=calc3(b0,b1,a1,las,c0),las=c0;
				ans+=calc1(las,w1);
			}
		}else{
			ans+=calc3(a0,a1,b0,las,c1),las=c1;
			c0=common(o,o+half,a1,a1+(a0-a1)*vec(0,1))[0];
			c1=common(o,o+half,b1,b1+(b0-b1)*vec(0,1))[0];
			if(dot(c0-c1,half)>0)swap(a0,b0),swap(a1,b1),swap(c0,c1);
			ans+=calc2(las,c0,half),las=c0;
			auto [w0,w1]=midline(a1,b1);
			if(dot(b1-b0,w1)<0)w1=-w1;
			c0=common(w0,w0+w1,b1,b1+(b0-b1)*vec(0,1))[0];
			ans+=calc3(b0,b1,a1,las,c0),las=c0;
			ans+=calc1(las,w1);
		}
	};
	solve(arg(b[0]-a[0])*vec(0,1));
	solve(arg(b[0]-a[0])*vec(0,-1));
}
void solve(vec a0,vec a1,vec b0,vec b1){
	vec u=arg(a1-a0);
	ans+=abs(a0-a1);
	b0+=a1-a0,a0=a1;
	vec las=(a0+b0)/ld(2);
	if(sign(abs(b0-b1))==0){
		ans+=calc1(las,u);
	}else{
		auto [v0,v1]=midline(a0,b1);
		if(dot(v1,b1-b0)<0)v1=-v1;
		vec c=common(v0,v0+v1,b1,b1+(b0-b1)*vec(0,1))[0];
		ans+=calc3(b0,b1,a0,las,c),las=c;
		ans+=calc1(las,v1);
	}
}
void solve2(){
	vec bm=(b[0]+b[1])/ld(2);
	vec am=bm-arg(a[1]-a[0])*vec(0,1)*(cross(a[1]-a[0],bm-a[0])/abs(a[0]-a[1]));
	solve(bm,b[1],am,a[1]);
	solve(bm,b[0],am,a[0]);
}
void solve3(){
	vec mid=(b[0]+a[1])/ld(2);
	vec am=mid-arg(a[1]-a[0])*vec(0,1)*(cross(a[1]-a[0],mid-a[0])/abs(a[0]-a[1]));
	vec bm=mid*ld(2)-am;
	solve(bm,b[0],am,a[0]);
	solve(am,a[1],bm,b[1]);
}
void work(){
	scanf("%d%d%d%d",&xl,&yl,&xr,&yr);
	bnd[0]=vec(xl,yl),bnd[1]=vec(xr,yl);
	bnd[2]=vec(xr,yr),bnd[3]=vec(xl,yr);
	read(a[0]),read(a[1]),read(b[0]),read(b[1]);
	int op=[&](){
		auto chk=[&](vec a0,vec a1,vec b0,vec b1){
			if(sign(cross(a1-a0,b0-a0))<=0)return 0;
			if(sign(cross(a1-a0,b0-a0)-cross(a1-a0,b1-a0))>=0)return 0;
			if(sign(dot(a1-a0,b0-a0))<=0)return 0;
			if(sign(dot(a0-a1,b0-a1))<=0)return 0;
			return 1;
		};
		for(int i:{0,1}){
			for(int j:{0,1}){
				if(chk(a[0],a[1],b[0],b[1]))return 0;
				swap(b[0],b[1]);
			}
			swap(a[0],a[1]);
		}
		swap(a[0],b[0]),swap(a[1],b[1]);
		for(int i:{0,1}){
			for(int j:{0,1}){
				if(chk(a[0],a[1],b[0],b[1]))return 0;
				swap(b[0],b[1]);
			}
			swap(a[0],a[1]);
		}
		if(sign(cross(a[1]-a[0],b[1]-b[0]))==0){
			auto cmp=[&](vec x,vec y){
				return sign(dot(y-x,a[1]-a[0]));
			};
			if(cmp(b[1],b[0])>0)swap(b[0],b[1]);
			if(cmp(b[0],a[0])>0)swap(a[0],b[0]),swap(a[1],b[1]);
			if(cmp(b[1],a[1])>=0)return 2;
			if(cmp(b[0],a[1])>=0)return 3;
		}
		tuple<ld,int,int>w[4];
		for(int i:{0,1})for(int j:{0,1}){
			w[i*2+j]={abs(a[i]-b[j]),i,j};
		}
		auto [d,i,j]=*min_element(w,w+4);
		if(i)swap(a[0],a[1]);
		if(j)swap(b[0],b[j]);
		return 1;
	}();
	ans=0;
	if(op==0)solve0();
	else if(op==1)solve1();
	else if(op==2)solve2();
	else solve3();
	printf("%.15Lf\n",ans);
}
int main(){
	for(scanf("%d",&T);T--;)work();
	return 0;
}
#ifdef DEBUG
#include"debug.hpp"
#endif