#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef tuple<int, int, int> tii;

inline int rd() {
    int x = 0;
    bool f = 0;
    char c = getchar();
    for (; !isdigit(c); c = getchar()) f |= (c == '-');
    for (; isdigit(c); c = getchar()) x = x * 10 + (c ^ 48);
    return f ? -x : x;
}

int gcd(int a, int b) {return b ? gcd(b, a % b) : a;}

typedef double T;
#define let const auto
#define lett const T
#define letp const P // P for point
#define letl const L // L for line
const T eps = 1e-5;
#define z(x) (abs((x)) <= eps) // is zero
 
inline int roundint(double x) {
    int y = ceil(x);
    for (int i = y - 1; i <= y + 1; ++i) if (z(x - i)) return i;
    return 2e9;
}
 
struct P {
    T x, y;
    P (T x = 0, T y = 0) : x(x), y(y) {}
    P operator + (letp &p) const {return {x + p.x, y + p.y};} 
    P operator - (letp &p) const {return {x - p.x, y - p.y};} 
    P operator * (lett &d) const {return {x * d, y * d};}
    P operator / (lett &d) const {return {x / d, y / d};}
    P operator - () const {return {-x, -y};}
 
    T operator | (letp &p) const {return x * p.x + y * p.y;} // dot
    T operator ^ (letp &p) const {return x * p.y - y * p.x;} // cross

    bool operator == (letp &p) const {return z(x - p.x) && z(y - p.y);}
    bool operator != (letp &p) const {return ! operator == (p);}
    bool operator < (letp &p) const {return z(x - p.x) ? y < p.y : x < p.x;}
    bool operator > (letp &p) const {return !(*this < p || *this == p);}

    T norm() const {return x * x + y * y;}
    P proj (letp &p) const {return (*this) * (((*this) | p) / norm());}
    P refl (letp &p) const {return proj(p) * 2 - p;}
} zero;

struct L {
    P p, v;
    P proj(letp &a) const {return p + v.proj(a - p);}
    P refl(letp &a) const {return p + v.refl(a - p);} 
};

set<P> s;

vector<tii> ans; 

inline void work() {
    s.clear(); ans.clear();
    int n = rd(), mxx = -1e9, mxy = -1e9, mnx = 1e9, mny = 1e9;
    auto add = [&](int x, int y) {
        P nw = P{1.0 * x, 1.0 * y};
        if (s.count(nw)) s.erase(nw); else s.insert(nw);
    };
    for (int i = 1; i <= n; ++i) {
        int x1 = rd(), y1 = rd(), x2 = rd(), y2 = rd();
        add(x1, y1); add(x1, y2); 
        add(x2, y1); add(x2, y2);
        mxx = max(mxx, x2); mnx = min(mnx, x1);
        mxy = max(mxy, y2); mny = min(mny, y1);
    }
    auto check = [&](L l) {
        for (auto p : s) if (s.count(l.refl(p)) == 0) return false;
        return true;
    };
    auto addans = [&](int a, int b, int c) {
        int g = gcd(gcd(abs(a), abs(b)), abs(c));
        a /= g; b /= g; c /= g;
        tii res = max(make_tuple(a, b, c), make_tuple(-a, -b, -c));
        ans.push_back(res);
    };
    // y = midy
    if (check(L{{0, (mxy + mny) / 2.0},{1, 0}})) addans(0, 2, mny + mxy);
    // x = midx
    if (check(L{{(mxx + mnx) / 2.0, 0},{0, 1}})) addans(2, 0, mnx + mxx);
    // "/"
    L l1{{(mxx + mnx) / 2.0, (mxy + mny) / 2.0}, {1, 1}};
    if (check(l1)) addans(roundint(2 * l1.v.y), roundint(-2 * l1.v.x), roundint(2 * (l1.p.x * l1.v.y - l1.p.y * l1.v.x)));
    // "\"
    l1 = L{{(mxx + mnx) / 2.0, (mxy + mny) / 2.0}, {1, -1}};
    if (check(l1)) addans(roundint(2 * l1.v.y), roundint(-2 * l1.v.x), roundint(2 * (l1.p.x * l1.v.y - l1.p.y * l1.v.x)));

    printf("%d\n", (int)ans.size());
    sort(ans.begin(), ans.end());
    reverse(ans.begin(), ans.end());
    for (auto [a, b, c] : ans) printf("%d %d %d ", a, b, c);
    puts("");
}

int main() {
    for (int t = rd(); t; --t) work();
    return 0;
}