#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() {}

### Prompt

Please create a solution in cpp to the following problem:

Have you ever tasted Martian food? Well, you should.

Their signature dish is served on a completely black plate with the radius of R, flat as a pancake.

First, they put a perfectly circular portion of the Golden Honduras on the plate. It has the radius of r and is located as close to the edge of the plate as possible staying entirely within the plate. I. e. Golden Honduras touches the edge of the plate from the inside. It is believed that the proximity of the portion of the Golden Honduras to the edge of a plate demonstrates the neatness and exactness of the Martians.

Then a perfectly round portion of Pink Guadeloupe is put on the plate. The Guadeloupe should not overlap with Honduras, should not go beyond the border of the plate, but should have the maximum radius. I. e. Pink Guadeloupe should touch the edge of the plate from the inside, and touch Golden Honduras from the outside. For it is the size of the Rose Guadeloupe that shows the generosity and the hospitality of the Martians.

Further, the first portion (of the same perfectly round shape) of Green Bull Terrier is put on the plate. It should come in contact with Honduras and Guadeloupe, should not go beyond the border of the plate and should have maximum radius.

Each of the following portions of the Green Bull Terrier must necessarily touch the Golden Honduras, the previous portion of the Green Bull Terrier and touch the edge of a plate, but should not go beyond the border.

To determine whether a stranger is worthy to touch the food, the Martians ask him to find the radius of the k-th portion of the Green Bull Terrier knowing the radii of a plate and a portion of the Golden Honduras. And are you worthy?

Input

The first line contains integer t (1 ≤ t ≤ 104) — amount of testcases.

Each of the following t lines contain three positive integers: the radii of the plate and a portion of the Golden Honduras R and r (1 ≤ r < R ≤ 104) and the number k (1 ≤ k ≤ 104).

In the pretests 1 ≤ k ≤ 2.

Output

Print t lines — the radius of the k-th portion of the Green Bull Terrier for each test. The absolute or relative error of the answer should not exceed 10 - 6.

Examples

Input

2
4 3 1
4 2 2


Output

0.9230769231
0.6666666667

Note

Dish from the first sample looks like this:

<image>

Dish from the second sample looks like this:

<image>

### Response

```cpp
#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() {}

```