#include<bits/stdc++.h>
using std::cin, std::cout;
using ll = long long;
using u64 = unsigned long long;
struct p2 { ll x, y; };
ll operator % (p2 x, p2 y) {
	return x.x * y.x + x.y * y.y;
}
p2 operator + (p2 x, p2 y) {
	return {x.x + y.x, x.y + y.y};
}
p2 operator * (p2 x, ll y) {
	return {x.x * y, x.y * y};
}
const int N = 1e6;
int T;
int n;
p2 a[N], b[N];
std::mt19937_64 gen(12345);
u64 h[N];
p2 r90(p2 x) { return {-x.y, x.x}; }
struct evt {
	ll x, l, r; int type;
};
std::vector<std::tuple<ll, ll, ll>> ans;
void push(ll a, ll b, ll c) {
	ll gcd = std::gcd(std::gcd(a, b), c);
	a /= gcd;
	b /= gcd;
	c /= gcd;
	if(a < 0) a *= -1, b *= -1, c *= -1;
	ans.emplace_back(a, b, c);
}
int M;
struct SGT {
	int min[N << 2], add[N << 2];
	u64 hash[N << 2];
	void update(int x) {
		min[x] = std::min(min[x << 1], min[x << 1 | 1]);
		hash[x] = 0;
		if(min[x] == min[x << 1]) hash[x] ^= hash[x << 1];
		if(min[x] == min[x << 1 | 1]) hash[x] ^= hash[x << 1 | 1];
	}
	void put(int x, int v) {
		min[x] += v;
		add[x] += v;
	}
	void down(int x) {
		put(x << 1, add[x]);
		put(x << 1 | 1, add[x]);
		add[x] = 0;
	}
	void build(int cur, int l, int r) {
		add[cur] = min[cur] = 0;
		if(l == r) {
			hash[cur] = h[l];
			return ;
		}
		int mid = (l + r) >> 1;
		build(cur << 1, l, mid);
		build(cur << 1 | 1, mid + 1, r);
		update(cur);
	}
	void apply(int ql, int qr, int v, int cur = 1, int l = 1, int r = M) {
		if(ql <= l && r <= qr) return put(cur, v);
		int mid = (l + r) >> 1;
		down(cur);
		if(ql <= mid) apply(ql, qr, v, cur << 1, l, mid);
		if(mid < qr) apply(ql, qr, v, cur << 1 | 1, mid + 1, r);
		update(cur);
	}
} sgt1, sgt2;
bool check(std::vector<evt> x) {
	std::vector<ll> o;
	for(auto [x, l, r, type] : x) {
		o.push_back(l);
		o.push_back(r);
	}
	sort(o.begin(), o.end()), M = o.size();
	auto get = [&](ll x) {
		return lower_bound(o.begin(), o.end(), x) - o.begin() + 1;
	};
	sort(x.begin(), x.end(), [&](auto & x, auto & y) { return x.x < y.x; });
	sgt1.build(1, 1, M);
	sgt2.build(1, 1, M);
	for(int i = 0, j = 0;i < (int) x.size();i = j) {
		for(j = i;j < (int) x.size() && x[i].x == x[j].x;++j) {
			auto [_, l, r, type] = x[j];
			auto & s = std::abs(type) == 1 ? sgt1 : sgt2;
			if(type > 0) {
				s.apply(get(l), get(r) - 1, 1);
			} else {
				s.apply(get(l), get(r) - 1, -1);
			}
		}
		if(sgt1.min[1] != sgt2.min[1] || sgt1.hash[1] != sgt2.hash[1]) {
			return 0;
		}
	}
	return 1;
}
void test(p2 d) {
	ll max = -1e18;
	ll min = 1e18;
	for(int i = 0;i < n;++i) {
		for(p2 z : {a[i], b[i]}) {
			max = std::max(max, z % d);
			min = std::min(min, z % d);
		}
	}
	ll mid = (max + min) / 2;
	auto flip = [&](p2 x) {
		ll dot = x % d, add = (max + min) - dot - dot;
		return x + d * (add / (d % d));
	};
	auto getx = [&](p2 x) { return x.x; };
	auto gety = [&](p2 x) { return x.y; };
	std::vector<evt> ee;
	for(int i = 0;i < n;++i) {
		//cout << i << " : ";
		auto push = [&](p2 a, p2 b, int t) {
		//	cout << a.x << ' ' << a.y << '\n';
		//	cout << b.x << ' ' << b.y << '\n';
			ee.push_back({
				std::min(getx(a), getx(b)),
					std::min(gety(a), gety(b)),
					std::max(gety(a), gety(b)),
					t
			});
			ee.push_back({
				std::max(getx(a), getx(b)),
					std::min(gety(a), gety(b)),
					std::max(gety(a), gety(b)),
					-t
			});
		};
		push(a[i], b[i], 1);
		push(flip(a[i]), flip(b[i]), 2);
		//cout << std::endl;
	}
	if(check(ee)) {
		push(d.x * 8, d.y * 8, mid);
	}
}
int main() {
#ifdef zqj
	freopen("$.in", "r", stdin);
#endif
	for(auto & x : h) x = gen();
	std::ios::sync_with_stdio(false), cin.tie(0);
	cin >> T;
	for(int i = 0;i < T;++i) {
		cin >> n;
		for(int i = 0;i < n;++i) {
			cin >> a[i].x >> a[i].y;
			cin >> b[i].x >> b[i].y;
			a[i].x *= 8; a[i].y *= 8;
			b[i].x *= 8; b[i].y *= 8;
		}

		ans = {};
		test({1, 0});
		test({1, 1});
		test({0, 1});
		test({1, -1});
		sort(ans.rbegin(), ans.rend());
		cout << ans.size() << '\n';
		for(auto [a, b, c] : ans) cout << a << ' ' << b << ' ' << c << ' ';
		cout << '\n';
	}
}