#include <bits/stdc++.h>

using namespace std;

#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()

typedef long long ll;
typedef pair<int, int> pii;

mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());

template<typename T>
std::ostream& operator << (std::ostream& os, const vector<T>& a) {
    for (const T& x : a) {
        os << x << ' ';
    }
    return os;
}

typedef long double real_t;

const real_t eps = 1e-10;
const real_t pi = acos(-1.0);

real_t v, R;

real_t f(real_t x) {
    real_t sx = sin(x);
    return R / (v * (sqrt(3 + sx * sx) - sx));
}

real_t simpson(real_t l, real_t r) {
    return real_t(1) / real_t(6) * (r - l) * (f(l) + real_t(4) * f((l + r) / real_t(2)) + f(r));
}

real_t Integral(real_t l, real_t r) {
    real_t m  = (l + r) / real_t(2);
    real_t tot = simpson(l, r);
    real_t sum = simpson(l, m) + simpson(m, r);
    if (abs(tot - sum) < eps) return sum;
    return Integral(l, m) + Integral(m, r);
}

real_t T(real_t alpha) {
    return Integral(0, alpha);
}

bool check(real_t x1, real_t y1, real_t x2, real_t y2) {
    //cout << x1 << ' ' << y1 << ' ' << x2 << ' ' << y2 << '\n';
    return x1 * x2 + y1 * y2 < 0;
}

void solve() {
    real_t d;
    cin >> v >> R >> d;
    R *= 2;

    real_t time = (d - 2 * R) / v;

    if (d <= 2 * R || time < T(pi)) {
        cout << d / v << '\n';
        return;
    }

    real_t low = pi / 2, high = pi;
    real_t ans = 1000;

    while (high - low > eps) {
        real_t mid = (low + high) / 2;
        real_t a = mid;
        real_t t = T(a);
        real_t Xc = R + v * t;
        real_t Yc = 0;
        real_t X = Xc + R * cos(pi - a);
        real_t Y = Yc + R * sin(pi - a);
        real_t dist = sqrt(Y * Y + (X - d) * (X - d));
        if (check(d - dist / 2 - X, -Y, Xc - X, Yc - Y)) {
            high = mid;
            ans = min(ans, t + dist / (2 * v));
        } else {
            low = mid;
        }
    }

    cout << ans << '\n';
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    cout.precision(15);

    int t;
    cin >> t;
    while (t--) {
        solve();
    }

    return 0;
}