#include <bits/stdc++.h>
using namespace std;
typedef long double LD;

const LD eps = 1e-11;

int sgn(LD x) { return x > eps ? 1 : (x < -eps ? -1 : 0); }

struct p2 {
    LD x, y;
    p2 operator + (const p2 &b) const { return {x + b.x, y + b.y}; }
    p2 operator - (const p2 &b) const { return {x - b.x, y - b.y}; }
    p2 operator * (const LD &b) const { return {x * b, y * b}; }
    p2 operator / (const LD &b) const { return {x / b, y / b}; }
    p2 rot90() const { return {-y, x}; }
    p2 unit() const { return *this / abs(); }
    LD abs() const { return sqrtl(x * x + y * y); }
    bool operator < (const p2 &b) const { return make_pair (x, y) < make_pair (b.x, b.y);}
    friend ostream & operator << (ostream &os, p2 a) {
    	return os << a.x << "," << a.y;
	}
};
LD det (p2 a, p2 b) { return a.x * b.y - a.y * b.x; }
LD dis (p2 a, p2 b) { return (a - b).abs(); }

int turn (p2 a, p2 b, p2 c) {
    return sgn(det(b - a, c - a));
}
struct l2 {
    p2 s, t;
    bool operator < (l2 a) const { return make_pair (s, t) < make_pair (a.s, a.t);}
};

bool two_side(p2 a, p2 b, l2 c) {
	return turn(c.s, c.t, a) * turn(c.s, c.t, b) < 0; }
p2 l2_inter(l2 a, l2 b) { // 直线交点
	LD s1 = det(a.t - a.s, b.s - a.s);
	LD s2 = det(a.t - a.s, b.t - a.s);
	return (b.s * s2 - b.t * s1) / (s2 - s1); }
vector <p2> cut (const vector<p2> &c, l2 l) {
	vector <p2> ret; // 线切凸包
	int n = (int) c.size(); if (!n) return ret;
	for (int i = 0; i < n; i++) {
		int j = (i + 1) % n;
		if (turn (l.s, l.t, c[i]) >= 0) ret.push_back(c[i]);
		if (two_side (c[i], c[j], l))
			ret.push_back(l2_inter(l, {c[i], c[j]})); }
	return ret; }

struct p3 {
    LD x, y, z;
    p3 operator + (const p3 &b) const { return {x + b.x, y + b.y, z + b.z}; }
    p3 operator - (const p3 &b) const { return {x - b.x, y - b.y, z - b.z}; }
    p3 operator * (const LD &b) const { return {x * b, y * b, z * b}; }
    p3 operator / (const LD &b) const { return {x / b, y / b, z / b}; }
    LD abs() const { return sqrtl(x * x + y * y + z * z); }
    p3 unit() const { return *this / abs(); }
};

p3 cross (p3 a, p3 b) {
    return {a.y * b.z - a.z * b.y, a.z * b.x - a.x * b.z, a.x * b.y - a.y * b.x};
}
LD dot (p3 a, p3 b) {
    return a.x * b.x + a.y * b.y + a.z * b.z;
}
LD dis (p3 a, p3 b) {
    return (a - b).abs();
}

struct plane {
	p3 nor; LD m;
	plane(p3 r, p3 a) : nor(r.unit()), m(dot(nor, a)) {}
};
struct l3 {
    p3 s, t;
};

p3 intersect(plane a, l3 b) {
	LD t = dot(a.nor, a.nor*a.m - b.s)/dot(a.nor, b.t - b.s);
	return b.s + (b.t - b.s) * t;
}

const p3 O (0, 0, 0);
void work() {
    vector <p3> image, screen;
    for (int i = 0; i < 4; i++) {
        int x, y, z;
        cin >> x >> y >> z;
        image.push_back((p3){x, y, z});
    }

    LD w = dis(image[0], image[1]);
    LD h = dis(image[0], image[3]);

    LD ratio = w / h;

    for (int i = 0; i < 4; i++) {
        int u, v, w;
        cin >> u >> v >> w;
        screen.push_back((p3){u, v, w});
    }

    plane img = plane(cross(image[1] - image[0], image[3] - image[0]), image[0]);
    plane wall = plane(cross(screen[1] - screen[0], screen[3] - screen[0]), screen[0]);
    vector <p3> init_proj;
    for (int i = 0; i < 4; i++) {
        init_proj.push_back(intersect(wall, {O, image[i]}));
    }


    // to 2D on wall plane
    vector <p2> A, B;
    for (int i = 0; i < 4; i++) {
        A.push_back((p2){dot(init_proj[i] - screen[0], (screen[1] - screen[0]).unit()), dot(init_proj[i] - screen[0], (screen[3] - screen[0]).unit())});
    }
    LD area = 0;
    for (int i = 0; i < 4; i++) {
        area += det(A[i], A[(i + 1) % 4]);
    }
    if (area < 0) {
        // cw -> ccw
        reverse(A.begin(), A.end());
    }
    for (int i = 0; i < 4; i++) {
        B.push_back((p2){dot(screen[i] - screen[0], (screen[1] - screen[0]).unit()), dot(screen[i] - screen[0], (screen[3] - screen[0]).unit())});
    }

    for (int i = 0; i < 4; i++) {
        A = cut(A, {B[i], B[(i + 1) % 4]});
    }
    for (auto &[x, y] : A) {
    	y *= ratio;
	}
	rotate(A.begin(), min_element(A.begin(), A.end()), A.end());
	int mx = 0;
	for (int i = 0; i < A.size(); i++) {
		if (A[mx].x < A[i].x) mx = i;
	}
	LD L = A[0].x, R = A[mx].x;
	vector < l2 > upper, lower;
	for (int i = 0; i < mx; i++) {
		lower.push_back({A[i], A[i + 1]});
		lower.back().s.y = -lower.back().s.y;
		lower.back().t.y = -lower.back().t.y;
	}
	for (int i = A.size() - 1; i >= mx; i--) {
		upper.push_back({A[(i + 1) % A.size()], A[i]});
	}
	vector < l2 > nu, nl;
	for (auto [s, t] : upper) {
		if (sgn(s.x - t.x)) nu.push_back({s, t});
	}
	for (auto [s, t] : lower) {
		if (sgn(s.x - t.x)) nl.push_back({s, t});
	}
	upper = nu;
	lower = nl;

	auto getp = [](l2 a, LD t) {
		return a.s + (a.t - a.s) * t;
	};
	auto eval = [&](l2 a, LD x) {
		return getp(a, (x - a.s.x) / (a.t.x - a.s.x)).y;
	};
	
	auto merge2 = [&] (vector <l2> a, vector <l2> b) -> vector <l2> {
		if (a.empty()) return {};
		int i = 0, j = 0;
		LD it = 0, jt = 0;
		while (j < b.size() && b[j].s.x < a[i].s.x) {
			if (b[j].t.x < a[i].s.x) j++;
			else {
				jt = (a[i].s.x - b[j].s.x) / (b[j].t.x - b[j].s.x);
				break;
			}
		}
		vector <l2> ret;
		while (i < a.size() && j < b.size()) {
			p2 as = getp(a[i], it);
			p2 bs = getp(b[j], jt);
			assert(abs(as.x - bs.x) < eps);
			LD ex = min(a[i].t.x, b[j].t.x);
			p2 at = getp(a[i], (ex - a[i].s.x) / (a[i].t.x - a[i].s.x));
			p2 bt = getp(b[j], (ex - b[j].s.x) / (b[j].t.x - b[j].s.x));
			{
				if (two_side(as, at, {bs, bt}) && two_side (bs, bt, {as, at})) {
					auto inter = l2_inter ({as, at}, {bs, bt});
					if (as.y < bs.y) {
						assert (at.y > bt.y);
						ret.push_back({as, inter});
						ret.push_back({inter, bt});
					} else {
						assert (bt.y > at.y);
						ret.push_back({bs, inter});
						ret.push_back({inter, at});
					}
				} else if ((as.y + at.y) < (bs.y + bt.y)) {
					ret.push_back({as, at});
				} else {
					ret.push_back({bs, bt});
				}
				it = (ex - a[i].s.x) / (a[i].t.x - a[i].s.x);
				jt = (ex - b[j].s.x) / (b[j].t.x - b[j].s.x);
			}
			if (it > 1 - eps) it = 0, i++;
			if (jt > 1 - eps) jt = 0, j++;
		}
		return ret;
	};

	auto ok = [&](LD l) {
		auto lower2 = lower;
		auto upper2 = upper;
		for (auto &[s, t] : lower2) s.x -= l, t.x -= l;
		for (auto &[s, t] : upper2) s.x -= l, t.x -= l;
		auto L = merge2(lower, lower2);
		auto R = merge2(upper, upper2);
		int i = 0, j = 0;
		LD ans = 0;
		auto check = [&] (int i, int j, LD x) {
			ans = max(ans, eval(L[i], x) + eval(R[j], x));
		};
		while (i < L.size() && j < R.size()) {
			check(i, j, max(L[i].s.x, R[j].s.x));
			check(i, j, min(L[i].t.x, R[j].t.x));
			if (L[i].t.x < R[j].t.x) {
				i ++;
			} else {
				j ++;
			}
		}
		return ans >= l;
	};

	LD l = 0, r = 8000;
	for (int _ = 0; _ < 80; _++) {
		LD mid = (l + r) / 2;
		if (ok(mid)) l = mid;
		else r = mid;
	}
    cout << l * l / ratio << '\n';
}


int main() {
    ios::sync_with_stdio(false); cin.tie(0);
    cout << setprecision(10) << fixed;
    cerr << fixed;
    int T; cin >> T;
    while (T--) work();
}