#include<bits/stdc++.h>
#pragma GCC optimize("Ofast")
namespace rgs = std::ranges;
using std::cin, std::cout;
using db = long double;
using cp = std::complex<db>;
const db eps = 1e-8;
db dot(cp u, cp v) {
	return u.real() * v.real() + u.imag() * v.imag();
}
db cross(cp u, cp v) {
	return u.real() * v.imag() - u.imag() * v.real();
}
cp r90(cp x) {
	return cp(-x.imag(), x.real());
}
struct hp : cp {
	db z;
	hp(cp o, db v = 0) : cp(o), z(v) {}
	hp pass(cp o) const {
		return hp(cp(*this), -dot(*this, o));
	}
	db val(cp v) const {
		return dot(v, *this) + z;
	}
	bool test(cp v) const {
		return val(v) >= -eps;
	}
};
using hps = std::vector<hp>;
cp get() {
	int x, y;
	cin >> x >> y;
	return cp(x, y);
}

hps R;
std::vector<cp> inter(hp x, hp y) {
	if(fabs(cross(x, y)) < eps) return {};
	return {
		cp(cross(cp(x.z, x.imag()), cp(y.z, y.imag())), cross(cp(x.real(), x.z), cp(y.real(), y.z)))/
			-cross(x, y)
	};
}
std::vector<cp> points;
const int N = 200;
db dist[N][N];
int getid(cp p) {
	for(int i = 0;i < (int) points.size();++i) {
		if(abs(p - points[i]) < eps) {
			return i;
		}
	}
	points.emplace_back(p);
	int id = points.size() - 1;
	for(int i = 0;i < id;++i) {
		dist[i][id] = 1e18;
		dist[id][i] = 1e18;
	}
	dist[id][id] = 0;
	return points.size() - 1;
}
void link(cp u, cp v, db d) {
	 // cout << "LINK " << u << ' ' << v << ' ' << d << '\n';
	int x = getid(u);
	int y = getid(v);
	dist[x][y] = std::min(dist[x][y], d);
	dist[y][x] = std::min(dist[y][x], d);
}
bool contains(const hps & R, cp p) {
	int ok = 1;
	for(const auto & l : R) {
		ok = ok && l.test(p);
	}
	return ok;
}
void add(const hps & R, hp l) {
	std::vector<cp> v;
	for(auto u : R) {
		for(auto p : inter(u, l)) {
			int ok = contains(R, p);
			for(auto pp : v) {
				ok = ok && abs(p - pp) > eps;
			}
			if(ok) {
				v.push_back(p);
			}
		}
	}
	assert(v.size() <= 2);
	if(v.size() == 2) {
		link(v[0], v[1], abs(v[0] - v[1]));
	}

}
void PP(auto u, auto v) {
	hps t = R;
	t.push_back(u.second);
	t.push_back(v.second);
	cp x = u.first, y = v.first;
	cp d = x - y;
	d /= abs(d);
	add(t, hp(d).pass((x + y) / (db)2));
}
std::vector<db> roots(db A, db B, db C) {
	db delta = B * B - 4 * A * C;
	if(delta < -eps) return {};
	delta = sqrt(std::max<db>(delta, 0));
	return {
		(-B - delta) / 2 / A,
		(-B + delta) / 2 / A,
	};
}
void PL(auto u, auto v) {
	hps t = R;
	t.push_back(u.second);
	// cout << u.second << '\n';
	t.push_back(v[1]); t.push_back(v[2]);
	cp x = u.first; hp l = v[0];
	cp rot = cp(l) / cp(0, 1);
	rot /= abs(rot);

	x /= rot;
	for(auto & l : t) l /= rot;
	l /= rot;
	db h = -l.z / l.imag();
	db a = x.real(), b = x.imag();
	if(fabs(b - h) < eps) {
		return ;
	}
	db A = 1, B = -2 * a, C = a * a + b * b - h * h;
	A /= 2 * (b - h);
	B /= 2 * (b - h);
	C /= 2 * (b - h);
	auto f = [&](db x) {
		return A * x * x + B * x + C;
	};
	std::vector<db> inters;
	// std::cout << "debug : ########### " << x * rot << std::endl;
	for(auto l : t) {
		// cout << cp(l) << ' ' << l.z << '\n';
		if(fabs(l.imag()) < eps) {
			inters.push_back(-l.z / l.real());
		} else {
			for(db x : roots(A, B + l.real() / l.imag(), C + l.z / l.imag())) {
				inters.push_back(x);
				cp p(x, f(x));
			}
		}
	}

	sort(inters.begin(), inters.end());
	inters.erase(unique(inters.begin(), inters.end(), [](db x, db y) { return fabs(x - y) < eps; }), inters.end());
	inters.erase(remove_if(inters.begin(), inters.end(), [&](db x) {
		return !contains(t, cp(x, f(x)));
	}), inters.end());
	for(int i = 1;i < (int) inters.size();++i) {
		db l = inters[i - 1], r = inters[i];
		db mid = (l + r) / 2;
		if(contains(t, cp(mid, f(mid)))) {
			auto integral = [](db a, db b, db c, db x) {
				db val = a * x * x + b * x + c, sval = sqrt(val);
				db s0 = (2 * a * x + b) / 4 / a * sval;
				db s1 = (4 * a * c - b * b) / (8 * sqrt(a * a * a)) * log(fabs(2 * a * x + b + 2 * sqrt(a) * sval));
				return s0 + s1;
			};
			db fa = 4 * A * A, fb = 4 * A * B, fc = B * B + 1;
			db len = integral(fa, fb, fc, r) - integral(fa, fb, fc, l);
			link(cp(l, f(l)) * rot, cp(r, f(r)) * rot, len);
		}
	}
}
void LL(auto u, auto v) {
	hps t = R;
	t.push_back(u[1]); t.push_back(u[2]);
	t.push_back(v[1]); t.push_back(v[2]);
	for(db z : {-1, 1}) {
		cp dir = u[0] + z * v[0];
		hp l(dir);
		l.z = (u[0].z + z * v[0].z);

		if(abs(dir) > eps) {
			l.z /= abs(dir);
			l /= abs(dir);
		}
		add(t, l);
	}
}

void solve() {
	cp l = get(), r = get();
	R = {
		hp(cp(1, 0)).pass(l),
		hp(cp(0, 1)).pass(l),
		hp(cp(-1, 0)).pass(r),
		hp(cp(0, -1)).pass(r),
	};
	auto input = [&]() {
		cp u = get();
		cp v = get();
		cp d = v - u;
		d /= abs(d);
		std::pair A(u, hp(-d).pass(u));
		std::pair B(v, hp(d).pass(v));
		std::array<hp, 3> C{hp(r90(d)).pass(u), hp(d).pass(u), hp(-d).pass(v)};
		return std::tuple(std::array{A, B}, C);
	};
	auto [A0, B0] = input();
	auto [A1, B1] = input();
	for(auto u : A0)
		for(auto v : A1)
			PP(u, v);
	for(auto u : A0)
		PL(u, B1);
	for(auto u : A1)
		PL(u, B0);
	LL(B0, B1);
	// for(auto c : points) {
	// 	cout << c << '\n';
	// }
	int N = points.size();
	for(int k = 0;k < N;++k) {
		for(int i = 0;i < N;++i) {
			for(int j = 0;j < N;++j) {
				dist[i][j] = std::min(dist[i][j], dist[i][k] + dist[k][j]);
			}
		}
	}
	std::vector<int> edge_ids;
	for(int i = 0;i < N;++i) {
		int ok = 0;
		for(auto l : R) {
			ok = ok || fabs(l.val(points[i])) < eps;
		}
		if(ok) edge_ids.push_back(i);
	}
	db ans = 1e18;
	for(int i : edge_ids)
		for(int j : edge_ids) if(i != j) {
			ans = std::min(ans, dist[i][j]);
		}
	if(ans > 1e15) {
		puts("0");
	} else {
		printf("%.20Lf\n", ans);
	}
	points = {};
}
int main() {
#ifdef zqj
	freopen("$.in", "r", stdin);
#endif
	std::ios::sync_with_stdio(false), cin.tie(0);
	int t;
	cin >> t;
	for(int i = 0;i < t;++i) {
		solve();
	}
}