#include <bits/stdc++.h>
#ifdef CKISEKI
#define safe cerr<<__PRETTY_FUNCTION__<<" line "<<__LINE__<<" safe\n"
#define debug(a...) qwe(#a, a)
#define orange(a...) dvo(#a, a)
using std::cerr;
template <typename ...T>
void qwe(const char *s, T...a) {
    cerr << "\e[1;32m(" << s << ") = (";
    int cnt = sizeof...(T);
    (..., (cerr << a << (--cnt ? ", " : ")\e[0m\n")));
}

template <typename Iter>
void dvo(const char *s, Iter L, Iter R) {
    cerr << "\e[1;32m[ " << s << " ] = [ ";
    for (int f = 0; L != R; ++L)
        cerr << (f++ ? ", " : "") << *L;
    cerr << " ]\e[0m\n";
}

#else
#define safe ((void)0)
#define debug(...) safe
#define orange(...) safe
#endif
using namespace std;

const int C = 255;

using LLF = long double;

LLF SQRT(LLF x) {
    return sqrt(max<LLF>(0, x));
}

LLF dist_2d(pair<LLF, LLF> p, pair<LLF, LLF> q) {
    return SQRT((p.first - q.first) * (p.first - q.first) + (p.second - q.second) * (p.second - q.second));
}

LLF dist(tuple<LLF, LLF, LLF> &&p, tuple<LLF, LLF, LLF> &&q) {
    auto [px, py, pz] = p;
    auto [qx, qy, qz] = q;
    return SQRT((px - qx) * (px - qx) + (py - qy) * (py - qy) + (pz - qz) * (pz - qz));
}

const LLF eps = 1e-9;

auto solve2(LLF x, LLF y) {
    vector<tuple<int,int,LLF>> ans;
    if (abs(x - C) <= eps && abs(y - C) <= eps) {
        LLF d = dist_2d(
                {0, 0},
                {C, C}
                );
        ans.emplace_back(C, C, d);
    } else if (x <= y) {
        LLF Y = C - (C - y) / (C - x) * C;
        LLF d = dist_2d(
                {0, Y},
                {x, y}
                );
        ans.emplace_back(0, C, Y);
        ans.emplace_back(C, C, d);
    } else {
        LLF X = C - (C - x) / (C - y) * C;
        LLF d = dist_2d(
                {X, 0},
                {x, y}
                );
        ans.emplace_back(C, 0, X);
        ans.emplace_back(C, C, d);
    }
    return ans;
}

tuple<LLF,LLF,LLF> check(auto f) {
    LLF rx = 0, ry = 0, rz = 0;
    for (auto [x, y, z, a]: f) {
        LLF vx = x - rx;
        LLF vy = y - ry;
        LLF vz = z - rz;
        LLF v = SQRT(vx*vx+vy*vy+vz*vz);
        rx += vx / v * min(v, a);
        ry += vy / v * min(v, a);
        rz += vz / v * min(v, a);
    }
    return { rx, ry, rz };
}

void solve() {
    int x, y, z;
    cin >> x >> y >> z;

    vector<tuple<int,int,int,LLF>> ans;

    if (x == C && y == C && z == C) {
        ans.emplace_back(C, C, C, dist({0, 0, 0}, {C, C, C}));
    } else if (x <= y && x <= z) {
        LLF Y = C - (C - y) / LLF(C - x) * C;
        LLF Z = C - (C - z) / LLF(C - x) * C;
        for (auto [xx, yy, amount]: solve2(Y, Z)) {
            ans.emplace_back(0, xx, yy, amount);
        }
        LLF d = dist(
                {0, Y, Z},
                {x, y, z}
                );
        ans.emplace_back(C, C, C, d);
    } else if (y <= x && y <= z) {
        LLF X = C - (C - x) / LLF(C - y) * C;
        LLF Z = C - (C - z) / LLF(C - y) * C;
        for (auto [xx, yy, amount]: solve2(X, Z)) {
            ans.emplace_back(xx, 0, yy, amount);
        }
        LLF d = dist(
                {X, 0, Z},
                {x, y, z}
                );
        ans.emplace_back(C, C, C, d);
    } else if (z <= x && z <= y) {
        LLF X = C - (C - x) / LLF(C - z) * C;
        LLF Y = C - (C - y) / LLF(C - z) * C;
        for (auto [xx, yy, amount]: solve2(X, Y)) {
            ans.emplace_back(xx, yy, 0, amount);
        }
        LLF d = dist(
                {X, Y, 0},
                {x, y, z}
                );
        ans.emplace_back(C, C, C, d);
    }

    cout << ans.size() << '\n';
    cout << fixed << setprecision(20);
    for (auto [X, Y, Z, a]: ans)
        cout << X << ' ' << Y << ' ' << Z << ' ' << a << '\n';
    auto [fx, fy, fz] = check(ans);
    debug(fixed, setprecision(20));
    debug(abs(fx - x));
    debug(abs(fy - y));
    debug(abs(fz - z));
}

int main() {
    cin.tie(nullptr)->sync_with_stdio(false);
    int T;
    cin >> T;
    while (T--) {
        solve();
    }

    return 0;
}