Ode to the Bridge Builder

#include <bits/stdc++.h>
using namespace std;

using ll = long long;

void setIO() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
}

using ld = long double;

struct Pt {
    ld x, y;
};

struct Op {
    int u, v, w;
};

Pt operator + (Pt a, Pt b) { return {a.x + b.x, a.y + b.y}; }
Pt operator - (Pt a, Pt b) { return {a.x - b.x, a.y - b.y}; }
Pt operator * (Pt a, ld k) { return {a.x * k, a.y * k}; }

ld dot(Pt a, Pt b) { return a.x * b.x + a.y * b.y; }
ld cross(Pt a, Pt b) { return a.x * b.y - a.y * b.x; }
ld norm(Pt a) { return sqrtl(dot(a, a)); }

Pt target;
int limitOps;
vector<Pt> pts;
vector<Op> ops;

pair<int,int> edgeKey(int a, int b) {
    if (a > b) swap(a, b);
    return {a, b};
}

void resetBuild() {
    pts.assign(3, {0, 0});
    pts[1] = {0, 0};
    pts[2] = {1, 0};
    ops.clear();
}

int addPoint(int u, int v, Pt z) {
    int id = (int)pts.size();
    pts.push_back(z);
    ops.push_back({u, v, id});
    return id;
}

int pieces(Pt v) {
    return max(0, (int)ceill(norm(v) - 1e-9L));
}

Pt projectPoint(Pt x, Pt a, Pt b) {
    Pt v = b - a;
    return a + v * (dot(v, x - a) / dot(v, v));
}

ld distLine(Pt x, Pt a, Pt b) {
    return fabsl(cross(a - x, b - x)) / norm(b - a);
}

Pt lineCircleForward(Pt o, Pt a, Pt b) {
    Pt v = b - a;
    Pt pj = projectPoint(o, a, b);
    ld d = distLine(o, a, b);
    ld h2 = 1.0L - d * d;
    if (h2 < 0) h2 = 0;
    return pj + v * (sqrtl(h2) / norm(v));
}

bool validBuild() {
    if ((int)ops.size() > limitOps) return false;
    set<pair<int,int>> edges;
    edges.insert({1, 2});
    bool hit = false;

    for (int i = 0; i < (int)ops.size(); i++) {
        auto [u, v, w] = ops[i];
        if (w != i + 3) return false;
        if (u < 1 || v < 1 || u > i + 2 || v > i + 2 || u == v) return false;
        if (!edges.count(edgeKey(u, v))) return false;

        ld a = norm(pts[u] - pts[w]);
        ld b = norm(pts[v] - pts[w]);
        if (a < 0.5L - 1e-8L || a > 1.0L + 1e-8L) return false;
        if (b < 0.5L - 1e-8L || b > 1.0L + 1e-8L) return false;

        edges.insert(edgeKey(u, w));
        edges.insert(edgeKey(v, w));
        if (norm(pts[w] - target) <= 1e-4L) hit = true;
    }
    return hit;
}

bool build1a() {
    resetBuild();
    Pt dir = target - pts[1];
    int s = pieces(dir);
    for (int i = 1; i < s; i++) {
        ld t = (ld)i / s;
        addPoint((int)pts.size() - 2, (int)pts.size() - 1, pts[1] + dir * t);
        addPoint((int)pts.size() - 2, (int)pts.size() - 1, pts[2] + dir * t);
    }
    addPoint((int)pts.size() - 2, (int)pts.size() - 1, target);
    return validBuild();
}

bool build1b() {
    resetBuild();
    Pt dir = target - pts[2];
    int s = pieces(dir);
    for (int i = 1; i <= s; i++) {
        ld t = (ld)i / s;
        addPoint((int)pts.size() - 2, (int)pts.size() - 1, pts[1] + dir * t);
        addPoint((int)pts.size() - 2, (int)pts.size() - 1, pts[2] + dir * t);
    }
    return validBuild();
}

bool build2() {
    resetBuild();
    Pt d = {sqrtl(3.0L) / 2.0L, 0.5L};
    addPoint(1, 2, d);

    Pt e = lineCircleForward(d, pts[2], target);
    if (norm(e - pts[2]) > 1.0L) {
        Pt dir0 = target - pts[2];
        e = pts[2] + dir0 * (1.0L / norm(dir0));
    }
    addPoint(2, 3, e);

    Pt dir = target - e;
    int s = pieces(dir);
    for (int i = 1; i <= s; i++) {
        ld t = (ld)i / s;
        addPoint((int)pts.size() - 2, (int)pts.size() - 1, d + dir * t);
        addPoint((int)pts.size() - 2, (int)pts.size() - 1, e + dir * t);
    }
    return validBuild();
}

bool build3a() {
    resetBuild();
    Pt d = {0.5L, sqrtl(3.0L) / 2.0L};
    addPoint(1, 2, d);

    Pt dir = target - pts[2];
    int s = pieces(dir);
    for (int i = 1; i < s; i++) {
        ld t = (ld)i / s;
        addPoint((int)pts.size() - 2, (int)pts.size() - 1, pts[2] + dir * t);
        addPoint((int)pts.size() - 2, (int)pts.size() - 1, d + dir * t);
    }
    addPoint((int)pts.size() - 2, (int)pts.size() - 1, target);
    return validBuild();
}

bool build3b() {
    resetBuild();
    Pt d = {0.5L, sqrtl(3.0L) / 2.0L};
    addPoint(1, 2, d);

    Pt dir = target - d;
    int s = pieces(dir);
    for (int i = 1; i <= s; i++) {
        ld t = (ld)i / s;
        addPoint((int)pts.size() - 2, (int)pts.size() - 1, pts[2] + dir * t);
        addPoint((int)pts.size() - 2, (int)pts.size() - 1, d + dir * t);
    }
    return validBuild();
}

int main() {
    setIO();

    int T;
    cin >> T;
    cout << fixed << setprecision(12);

    while (T--) {
        int p, q, m;
        cin >> p >> q >> m;
        target = {(ld)p, (ld)q};
        limitOps = m;

        bool ok = build1a();
        if (!ok) ok = build1b();
        if (!ok) ok = build2();
        if (!ok) ok = build3a();
        if (!ok) ok = build3b();
        assert(ok);

        cout << ops.size() << '\n';
        for (auto [u, v, w] : ops) {
            cout << u << ' ' << v << ' ' << (double)pts[w].x << ' ' << (double)pts[w].y << '\n';
        }
    }
}