#pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef unsigned long long int ull;

mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
ll myRand(ll B) {
    return (ull)rng() % B;
}
inline double time() {
    return static_cast<long double>(chrono::duration_cast<chrono::nanoseconds>(chrono::steady_clock::now().time_since_epoch()).count()) * 1e-9;
}

// 3D points
// AOJ 1331
struct _3Dpoint{
    double x,y,z;
    _3Dpoint(){}
    _3Dpoint(double x,double y,double z): x(x), y(y), z(z) {}
    _3Dpoint& operator-=(const _3Dpoint &p){
        x -= p.x; y -= p.y; z -= p.z;
        return *this;
    }
    _3Dpoint& operator+=(const _3Dpoint &p){
        x += p.x; y += p.y; z += p.z;
        return *this;
    }
    _3Dpoint& operator*=(double d){
        x *= d; y *= d; z *= d;
        return *this;
    }
    _3Dpoint& operator/=(double d){
        x /= d; y /= d; z /= d;
        return *this;
    }
    const _3Dpoint operator+ (const _3Dpoint& p) const;
    const _3Dpoint operator- (const _3Dpoint& p) const;
    const _3Dpoint operator* (double d) const;
    const _3Dpoint operator/ (double d) const;
};
const _3Dpoint _3Dpoint::operator+ (const _3Dpoint& p) const{
    _3Dpoint res(*this); return res += p;
}
const _3Dpoint _3Dpoint::operator- (const _3Dpoint& p) const{
    _3Dpoint res(*this); return res -= p;
}
const _3Dpoint _3Dpoint::operator* (double d) const{
    _3Dpoint res(*this); return res *= d;
}
const _3Dpoint _3Dpoint::operator/ (double d) const{
    _3Dpoint res(*this); return res /= d;
}
struct _3Dline{
    _3Dpoint A,B;
    _3Dline(_3Dpoint A,_3Dpoint B):A(A),B(B){}
};
// A to B
_3Dpoint vec(_3Dline L){
    return L.B-L.A;
}
double abs(_3Dpoint P){
    return sqrt(P.x*P.x+P.y*P.y+P.z*P.z);
}
double dist(_3Dpoint A,_3Dpoint B){
    return abs(A-B);
}

_3Dpoint go(_3Dpoint s, _3Dpoint g, double d) {
    _3Dpoint v = vec(_3Dline(s, g));
    double sz = abs(v);
    assert(abs(sz) > 1e-8);
    _3Dpoint res = s + v * min(d, sz) / sz;
    return res;
}

// (s,g)を結ぶ直線と(?,?,z)の交点
_3Dpoint cross_point(_3Dpoint s, _3Dpoint g, double z) {
    auto t = g-s;
    assert(abs(t.z) > 1e-8);
    double u = (z-s.z)/(t.z);
    s += t*u;
    s.z = z;
    return s;
}

void slv(int x, int y, int z) {
    _3Dpoint goal = _3Dpoint(x,y,z);
    _3Dpoint xy, ve;

    auto chk = [&](_3Dpoint p)->bool{
        if (0 <= p.x and p.x <= 255 and 0 <= p.y and p.y <= 255) return true;
        return false;
    };
    auto find = [&]() -> void {
        // xy平面上から(?,?,255)を使う場合
        if (goal.z != 255) {
            for (int i = 0; i < 4; ++i) {
                double xx = 0;
                double yy = 0;

                if (1LL<<0&i) xx = 255;
                if (1LL<<1&i) yy = 255;

                _3Dpoint uu = _3Dpoint(xx,yy,255);

                auto p = cross_point(goal, uu, 0);
                if (chk(p)) {
                    xy = p; ve = uu;
                    return;
                }
            }
        }
        // z=255から(?,?,0)を使う場合
        if (goal.z != 0) {
            for (int i = 0; i < 4; ++i) {
                double xx = 0;
                double yy = 0;

                if (1LL<<0&i) xx = 255;
                if (1LL<<1&i) yy = 255;

                _3Dpoint uu = _3Dpoint(xx,yy,0);

                auto p = cross_point(goal, uu, 255);
                if (chk(p)) {
                    xy = p; ve = uu;
                    return;
                }
            }
        }
    };
    find();

    vector<pair<_3Dpoint,double>> res;
    _3Dpoint cur = _3Dpoint(0,0,0);
    auto psh = [&](_3Dpoint p, double d) -> void {
        res.push_back({p, d});
        cur = go(cur, p, d);
        assert(0 <= cur.x and cur.x <= 255);
        assert(0 <= cur.y and cur.y <= 255);
        assert(0 <= cur.z and cur.z <= 255);
    };

    if (xy.z == 255) {
        psh(_3Dpoint(0,0,255), 5000);
    }
    {
        if (xy.x == 255) {
            psh(_3Dpoint(255, 0, xy.z), 5000);
            psh(_3Dpoint(255, 255, xy.z), xy.y);
        }
        else if (xy.y + xy.x <= 255) {
            double d = 255.0 / (255 - xy.x) * xy.y;
            psh(_3Dpoint(0, 255, xy.z), d);
            // 今(0,d,?)にいるハズ

            auto p1 = (_3Dpoint(0, d, xy.z) - xy);
            d = abs(p1);
            psh(_3Dpoint(255, 0, xy.z), d);
        }
        else {
            psh(_3Dpoint(255, 255, xy.z), 5000);

            double d = 255.0 / xy.y * (255 - xy.x);
            psh(_3Dpoint(0, 255, xy.z), d);
            // 今(0,d,?)にいるハズ

            auto p1 = (_3Dpoint(255 - d, 255, xy.z) - xy);
            d = abs(p1);
            psh(_3Dpoint(255, 0, xy.z), d);
        }
    }

    {
        double dd = abs(cur - goal);
        psh(ve, dd);
    }

    assert(res.size() <= 10);
    printf("%d\n", (int)res.size());
    for (auto &p:res) {
        assert(0 <= p.second and p.second <= 10000);
        int rx = (int)p.first.x;
        int ry = (int)p.first.y;
        int rz = (int)p.first.z;
        assert(rx == 0 or rx == 255);
        assert(ry == 0 or ry == 255);
        assert(rz == 0 or rz == 255);
        printf("%d %d %d %.9f\n", (int)p.first.x, (int)p.first.y, (int)p.first.z, max(0.0, p.second));
    }
    const double eps = 1e-8;
    assert(abs((double )x-cur.x) <= eps);
    assert(abs((double )y-cur.y) <= eps);
    assert(abs((double )z-cur.z) <= eps);
}

int main(){
    cin.tie(nullptr);
    ios::sync_with_stdio(false);
   int q; cin >> q;
   while (q--) {
       int x,y,z;
       cin >> x >> y >> z;
//        x = myRand(256), y = myRand(256), z = myRand(256);
       slv(x, y, z);
   }
//    return 0;
    // for (int i = 0; i < 256; ++i) {
    //     for (int j = 0; j < 256; ++j) {
    //         for (int k = 0; k < 256; ++k) {
    //             slv(i, j, k);
    //         }
    //     }
    // }
}