#include <bits/stdc++.h>
inline void DoNothing() {}
template <typename T>
inline T Abs(const T a) {
  return a < 0 ? -a : a;
}
template <typename T>
inline T Min(const T a, const T b) {
  return a < b ? a : b;
}
template <typename T>
inline T Max(const T a, const T b) {
  return a > b ? a : b;
}
static const long double eps = 1.0e-07;
template <typename T>
inline T IsEqual(const T a, const T b) {
  return Abs(a - b) < eps;
}
template <typename T>
inline T IsGreater(const T a, const T b) {
  return a > b + eps;
}
template <typename T>
inline T IsLess(const T a, const T b) {
  return a + eps < b;
}
template <typename T>
inline void Print(const T& val) {
  std::cout << val << ' ';
}
template <typename T>
inline std::string ToStr(const T& val) {
  std::ostringstream ostr;
  ostr << val;
  return ostr.str();
}
template <typename T>
inline bool FromStr(const std::string& str, T& val) {
  std::istringstream istr(str);
  istr >> val;
  return !!istr;
}
struct Rand {
  unsigned long z_, w_;
  unsigned long get32() {
    z_ = 36969 * (z_ & 65535) + (z_ >> 16);
    w_ = 18000 * (w_ & 65535) + (w_ >> 16);
    return (z_ << 16) + (w_ & 65535);
  }
  void Reset() {
    z_ = 1;
    w_ = 1;
  }
  Rand() { Reset(); }
};
template <typename T>
inline std::vector<std::vector<T> > CreateVector2d(const size_t rowCnt,
                                                   const size_t colCnt) {
  return std::vector<std::vector<T> >(rowCnt, std::vector<T>(colCnt));
}
void Prepare();
class StopWatchEx {
 public:
  StopWatchEx();
  ~StopWatchEx();

 private:
  struct Data;
  Data* pData;
};
inline double CalcRk(const double rb, const double rs, size_t k) {
  const double i_ds = 1 / (2 * rs);
  const double i_db = 1 / (2 * rb);
  const double i_d = i_ds - i_db;
  const double i_xc = i_db + i_d / 2;
  const double i_yc = i_d * (double)(k);
  const double i_c = sqrt(i_yc * i_yc + i_xc * i_xc);
  const double z1 = 1 / (i_c - i_d / 2);
  const double z2 = 1 / (i_c + i_d / 2);
  const double rk = (z1 - z2) / 2;
  return rk;
}
bool Solve(bool bCheckInputStream = false) {
  size_t n;
  std::cin >> n;
  if (bCheckInputStream && !std::cin) {
    return false;
  }
  StopWatchEx _sw;
  for (size_t i = 0; i < n; i++) {
    size_t rb, rs, k;
    std::cin >> rb >> rs >> k;
    const double rk = CalcRk((double)rb, (double)rs, k);
    std::cout << std::setprecision(8) << std::setw(12) << rk << std::endl;
  }
  return true;
}
int main() {
  Prepare();
  Solve();
}
struct StopWatchEx::Data {};
StopWatchEx::StopWatchEx() {}
StopWatchEx::~StopWatchEx() {}
void Prepare() {}
