#include <iostream>
#include <tuple>
#include <vector>
#include <cassert>
#include <complex>
#include <cmath>
#include <iomanip>

#define EPS 1e-12

using namespace std;

template<class type>
using Point3d = tuple<type, type, type>;
using Point = complex<double>;

const double a = 255;
vector<Point3d<int>> corners;
Point3d<int> black = {0, 0, 0};

void insertCorners() {
	corners.emplace_back(0, 0, 0);
	corners.emplace_back(0, 0, a);
	corners.emplace_back(a, 0, a);
	corners.emplace_back(a, 0, 0);
	corners.emplace_back(0, a, a);
	corners.emplace_back(a, a, a);
	corners.emplace_back(a, a, 0);
	corners.emplace_back(0, a, 0);
}


int sign(double x) {
	if (x < -EPS) {
		return -1;
	} else if (x > EPS) {
		return 1;
	} else {
		return 0;
	}
}

Point3d<double> operator* (Point3d<double>& lhs, double rhs) {
	double x, y, z;
	tie(x, y, z) = lhs;
	return {x * rhs, y * rhs, z * rhs};
}

Point3d<double> operator- (Point3d<double>& lhs, Point3d<int>& rhs) {
	double x1, y1, z1; tie(x1, y1, z1) = lhs;
	double x2, y2, z2; tie(x2, y2, z2) = rhs;
	return {x1 - x2, y1 - y2, z1 - z2};
}

double dist(Point3d<double> lhs, Point3d<double> rhs) {
	double x1, y1, z1; tie(x1, y1, z1) = lhs;
	double x2, y2, z2; tie(x2, y2, z2) = rhs;
	x2 -= x1; y2 -= y1; z2 -= z1;
	return sqrt(x2 * x2 + y2 * y2 + z2 * z2);
}

bool OnSegment(Point3d<double>& p1, Point3d<double>& p2, Point3d<double>& p) {
	return (sign(dist(p1, p) + dist(p2, p) - dist(p1, p2)) == 0);
}

bool OnSegment(Point3d<int>& lhs, Point3d<int>& rhs, Point3d<double>& p) {
	double x1, y1, z1; tie(x1, y1, z1) = lhs;
	Point3d<double> p1 = {x1, y1, z1};

	double x2, y2, z2; tie(x2, y2, z2) = rhs;
	Point3d<double> p2 = {x2, y2, z2};

	return OnSegment(p1, p2, p);
}

double cross(Point a, Point b) {
	return a.real() * b.imag() - a.imag() * b.real();
}

double det(Point a, Point b, Point c) {
	return cross(b - a, c - a);
}

double dot(Point a, Point b) {
	return a.real() * b.real() + a.imag() * b.imag();
}

bool OnSegment(Point s, Point e, Point p) {
	return sign(det(p, s, e)) == 0 && sign(dot(s - p, e - p)) <= 0;
}

int InsidePoligon(vector<Point>& P, const Point& p) {
	int ic = 0, n = P.size();
	for (int i = 0, j = n - 1; i < n; j = i++) {
		if (OnSegment(P[i], P[j], p)) return 0;
		ic += (max(P[i].imag(), P[j].imag()) > p.imag() &&
			min(P[i].imag(), P[j].imag()) <= p.imag() &&
			(det(P[i], P[j], p) > 0) == (P[i].imag() <= p.imag()));
	}
	return ic % 2 ? 1 : -1;
}

Point LineIntersection(Point a, Point b, Point p, Point q) {
	double c1 = det(a, b, p);
	double c2 = det(a, b, q);
	assert(sign(c1 - c2));
	return (q * c1 - p * c2) / (c1 - c2);
}

bool isBlack(const Point3d<double>& p) {
	return (sign(get<0>(p)) == 0 && sign(get<1>(p)) == 0 && sign(get<2>(p)) == 0);
}

bool isPoint(Point3d<double> p) {
	for (auto c : corners) {
		bool ok = true;
		if (sign(get<0>(p) - get<0>(c)) == 0
			&& sign(get<1>(p) - get<1>(c)) == 0
			&& sign(get<2>(p) - get<2>(c)) == 0) {
			return true;
		}
	}
	return false;
}

bool isLatura(Point3d<double> p) {
	for (int i = 0; i < corners.size(); i++) {
		for (int j = 0; j < corners.size(); j++) {
			if (i == j) { continue; }
			if (OnSegment(corners[i], corners[j], p)) {
				return true;
			}
		}
	}
	return false;
}

void SolvePoint(Point3d<double>& p1, vector<pair<Point3d<int>, double>>& ans) {
	for (int i = 0; i < corners.size(); i++) {
		if (isBlack(p1 - corners[i])) {
			ans.emplace_back(corners[i], 3 * a);
			return;
		}
	}
}

void SolveLatura(Point3d<double>& p1, vector<pair<Point3d<int>, double>>& ans) {
	for (int i = 0; i < corners.size(); i++) {
		for (int j = 0; j < corners.size(); j++) {
			if (i == j) { continue; }
			if (OnSegment(corners[i], corners[j], p1)) {
				ans.emplace_back(corners[i], 3 * a);
				ans.emplace_back(corners[j], dist(corners[i], p1));
				return;
			}
		}
	}
}

void PrintPoint(Point p) {
	cerr << "!! " << p.real() << " " << p.imag() << endl;
}

void PrintPoint(Point3d<double> p) {
	double x, y, z; tie(x, y, z) = p;
	cerr << fixed << setprecision(3) << x << " " << y << " " << z << endl;
}

void SolveFataKnown(Point p, vector<int>& id, vector<Point>& p2d, vector<pair<Point3d<int>, double>>& ans) {
	ans.emplace_back(corners[id[0]], 3 * a);
	auto aux = p2d;
	aux.pop_back();
	Point p2;

	// PrintPoint(p);
	
	if (InsidePoligon(aux, p) != -1) {
		// PrintPoint(p2d[2]);
		// PrintPoint(p2d[0]);
		// PrintPoint(p2d[1]);

		p2 = LineIntersection(p, p2d[2], p2d[0], p2d[1]);
		// PrintPoint(p2);
		// PrintPoint(p);
		// PrintPoint(p2d[2]);
		// PrintPoint(p2d[0]);
		// PrintPoint(p2d[1]);

		ans.emplace_back(corners[id[1]], abs(p2 - p2d[0]));
		ans.emplace_back(corners[id[2]], abs(p2 - p));
	} else {
		p2 = LineIntersection(p, p2d[2], p2d[0], p2d[3]);
		// PrintPoint(p2);
		// PrintPoint(p);
		// PrintPoint(p2d[2]);
		// PrintPoint(p2d[0]);
		// PrintPoint(p2d[1]);

		ans.emplace_back(corners[id[3]], abs(p2 - p2d[0]));
		ans.emplace_back(corners[id[2]], abs(p2 - p));
	}
}

void SolveFata(Point3d<double>& p1, vector<pair<Point3d<int>, double>>& ans) {
	int face = -1;
	if (sign(get<0>(p1) - a) == 0) {
		face = 0;
	} else if (sign(get<1>(p1) - a) == 0) {
		face = 1;
	} else if (sign(get<2>(p1) - a) == 0) {
		face = 2;
	}
	assert(face != -1);
	
	Point p;
	vector<int> face_id;
	vector<Point> face_2d;
	if (face == 0) {
		p = {get<1>(p1), get<2>(p1)};
		face_id = {2, 3, 6, 5};
		for (auto i : face_id) {
			face_2d.emplace_back(get<1>(corners[i]), get<2>(corners[i]));
		}
	} else if (face == 1) {
		p = {get<0>(p1), get<2>(p1)};
		face_id = {7, 4, 5, 6};
		for (auto i : face_id) {
			face_2d.emplace_back(get<0>(corners[i]), get<2>(corners[i]));
		}
	} else {
		p = {get<0>(p1), get<1>(p1)};
		face_id = {1, 2, 5, 4};
		for (auto i : face_id) {
			face_2d.emplace_back(get<0>(corners[i]), get<1>(corners[i]));
		}
	}

	SolveFataKnown(p, face_id, face_2d, ans);
}

vector<pair<Point3d<int>, double>> Solve(double x, double y, double z) {
	Point3d<double> p = {x, y, z};

	if (isBlack(p)) {
		return vector<pair<Point3d<int>, double>>();
	}

	double sigma = a / max(max(x, y), z);
	Point3d<double> p1 = p * sigma;

	vector<pair<Point3d<int>, double>> ans;

	if (isPoint(p1)) {
		SolvePoint(p1, ans);
	} else if (isLatura(p1)) {
		SolveLatura(p1, ans);
	} else {
		SolveFata(p1, ans);
	}

	// PrintPoint(p);
	ans.emplace_back(black, dist(p1, p));

	assert(ans.size() <= 10);
	return ans;
}

int main() {
	insertCorners();

	int t; cin >> t;
	for (int i = 0; i < t; i++) {
		double x, y, z; cin >> x >> y >> z;

		auto ans = Solve(x, y, z);
		
		// cerr << endl;
		cout << ans.size() << "\n";
		for (int i = 0; i < ans.size(); i++) {
			int x, y, z;
			tie(x, y, z) = ans[i].first;
			cout << x << " " << y << " " << z << " " << fixed << setprecision(8) << ans[i].second << "\n";
		}
	}
	return 0;
}