Gohan has found his way into Dr. Gero's lab. There, he finds a circuit. He starts to toy with it. He finds the inverse transverse function $(V_{in}/V_{out})$ i.e (itf) of the circuit. 

Dr. Gero finds out about this. He gives Gohan an $s$-controller, through which he can randomly change the values of $s$. He finds out that each value of itf can be achieved through multiple values of $s$. But for a single particular value of itf, he finds out that this is not true. That is, just for this particular value of itf, there is only a single value of $s$ which achieves it. 

To avoid punishment, Gohan must complete a task given to him by Dr.Gero, which is to find this particular value of itf. He needs your help in doing that.

HINT to solve these type of circuits. In these circuits, the capacitor and the inductor can be treated as normal resistors, with resistances as follows: The resistance of inductor is directly taken as (s * L) and that of capacitor is 1/(s * C).

------ Input: ------

The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first and only line of each test case contains 4 integers $R, L, C, V_{in}$, separated by single spaces. 

------ Output: ------
For each test case, print a single line containing the answer. Your answer will be judged right if it is at most $10^{-2}$ away from the correct answer.

------ Constraints  ------
$1 ≤ T ≤ 2$
$1 ≤ R ≤ 10^{5}$
$1 ≤ L ≤ 10^{5}$
$1 ≤ C ≤ 10^{5}$
$1 ≤ V_{in} ≤ 10^{9}$

----- Sample Input 1 ------ 
2
4 5 78 60
4 5 6 3
----- Sample Output 1 ------ 
-61.4
-3.8

Difficulty: MEDIUM_HARD

Starter code:

Solutions:
t = int(input())
for _ in range(t):
	(r, l, c, lol) = [float(a) for a in input().split()]
	R = r
	C = c
	L = l
	val = -R / (2 * L)
	ans = val * val * L * C + 1 + R * val * c
	print(ans)


t = int(input())
while t:
	t -= 1
	(r, l, c, v) = list(map(int, input().split()))
	print(1 - c * r * r / (4 * l))


import sys
n = int(input())
for i in range(n):
	s = input().split(' ')
	r = int(s[0])
	l = int(s[1])
	c = int(s[2])
	res = 1 - 1.0 * r * r * c / (4 * l)
	print(round(res, 2))


for _ in range(int(input().strip())):
	(r, l, c, v) = [int(i) for i in input().strip().split()]
	print(1 - r * r * c / (4 * l))


def ii():
	return int(input())

def mi():
	return map(int, input().split())

def li():
	return list(map(int, input().split()))
for _ in range(ii()):
	(r, l, c, v) = mi()
	print(1 - r * r * c / (4 * l))


for t in range(int(input())):
	(R, L, C, V) = map(float, input().split())
	print(1 - R * R * C / (4 * L))


t = int(input())
for _ in range(t):
	inp = list(map(int, input().split()))
	r = inp[0]
	l = inp[1]
	c = inp[2]
	w = inp[3]
	print(1 - r * r * c / (l * 4))


T = int(input())
for test in range(T):
	(R, L, C, Vin) = map(float, input().split())
	Vout = R * R * C / (4 * L) - 1
	Vout = -Vout
	print(Vout)


T = int(input())
for _ in range(T):
	(R, L, C, Vin) = input().split()
	(R, L, C, Vin) = (float(R), float(L), float(C), float(Vin))
	U = R * R * C
	D = 4 * L
	an = -(U / D - 1)
	print('%.6f' % an)


t = int(input())
for _ in range(t):
	(r, l, c, vin) = map(int, input().split())
	s = -r / (2 * l)
	res = s * s * l * c + 1 + s * r * c
	print(res)


from sys import stdin
t = int(stdin.readline().rstrip())
for i in range(t):
	inp = stdin.readline().rstrip()
	(r, l, c, v) = inp.split(' ')
	(R, L, C) = (int(r), int(l), int(c))
	itf = -(R * R * C / (4 * L)) + 1
	print('{:.2f}'.format(itf))


for _ in range(int(input())):
	(r, l, c, v) = map(int, input().split())
	ans = 1 - r * r * c / (4 * l)
	print(float(ans))


t = int(input())
for i in range(0, t):
	a = input().split()
	R = int(a[0])
	L = int(a[1])
	C = int(a[2])
	V = int(a[3])
	p = 1 - R * R * C / (4 * L)
	print(p)


a = int(input())
while a > 0:
	a = a - 1
	lis = list(map(int, input().split(' ')))
	r = lis[0]
	l = lis[1]
	c = lis[2]
	v = lis[3]
	x = 1 - r * r * c / (4 * l)
	print(x)


t = int(input())
for vi in range(0, t):
	(r, l, c, v) = input().split()
	(r, l, c, v) = [int(r), int(l), int(c), int(v)]
	b = r * r * c / (4 * l)
	bn = 1 - b
	print(bn)


t = int(input())
while t > 0:
	lt = list(map(int, input().split(' ')))
	r = lt[0]
	l = lt[1]
	c = lt[2]
	v = lt[3]
	p = r * r * c
	p = p / 4
	p = p / l
	p = 1 - p
	print(p)
	t = t - 1


t = int(input())
while t:
	l = [int(x) for x in input().split()]
	print(1 - l[0] * l[0] * l[2] / (4 * l[1]))
	t -= 1


t = int(input())
while t > 0:
	t = t - 1
	(r, l, c, v) = map(int, input().split())
	res = -r * r * c / (4 * l)
	print(res + 1)


t = int(input())
for test in range(t):
	(r, l, c, vin) = map(int, input().split())
	ans = 1 - r ** 2 * c / (4 * l)
	print(ans)


for i in range(int(input())):
	(r, l, c, v) = map(float, input().split(' '))
	k = 0.0
	k = 1 - r * r * c / (4 * l)
	print(k)


for i in range(0, int(input())):
	(a, b, c, d) = input().split()
	a = int(a)
	b = int(b)
	c = int(c)
	s = -(a / (2 * b))
	print(s * s * b * c + a * c * s + 1)


nTestcases = int(input())
for i in range(nTestcases):
	(R, L, C, Vin) = [int(j) for j in input().split()]
	s = -R / (2 * L)
	itf = s * s * L * C + R * C * s + 1
	print(itf)


t = int(input())
for _ in range(t):
	arr = input().split(' ')
	R = int(arr[0])
	L = int(arr[1])
	C = int(arr[2])
	V = int(arr[3])
	ans = 1 - R * R * C / (4 * L)
	print('%.2f' % ans)


for t in range(int(input())):
	(r, l, c, v) = map(int, input().split(' '))
	print(1 - c * r * r / (4 * l))


T = int(input())
for _ in range(T):
	(R, L, C, Vin) = [int(i) for i in input().split()]
	s = -R / (2 * L)
	ans = s ** 2 * L * C + R * C * s + 1
	print(ans)


for _ in range(int(input())):
	(r, l, c, v) = map(float, input().split())
	x = -r / (2 * l)
	ans = x * x * l * c + x * r * c + 1
	print(ans)


t = int(input())
while t:
	t -= 1
	arr = input().split()
	for i in range(4):
		arr[i] = int(arr[i])
	itf = 1 - (arr[0] * arr[2]) ** 2 / (4 * arr[1] * arr[2])
	print(itf)


t = int(input())
while t > 0:
	t -= 1
	s = input()
	s_list = s.split()
	r = float(s_list[0])
	l = float(s_list[1])
	c = float(s_list[2])
	vi = float(s_list[3])
	itf = (-1 * r * r * c + 4 * l) / (4 * l)
	itf += 1e-08
	print(itf)


def f(r, l, c):
	return 1 - c / 4 * r ** 2 / l
t = int(input())
for i in range(t):
	(r, l, c, v) = list(map(int, input().split()))
	print(f(r, l, c))


t = input()
t = int(t)
for i in range(0, t):
	(r, l, c, v) = input().split()
	r = int(r)
	l = int(l)
	c = int(c)
	v = int(v)
	z = 4
	a = r * r * c * c
	b = z * l * c
	q = a / b
	z = 1
	q = z - q
	print(q)


a = int(input())
for i in range(a):
	(b, c, d, e) = [int(j) for j in input().split()]
	print(1 - b ** 2 * d / (4 * c))


for _ in range(int(input())):
	(R, L, C, VIN) = [int(j) for j in input().split()]
	print(1 - R * R * C / (4 * L))


for _ in range(int(input())):
	(r, l, c, v) = map(int, input().split())
	s = -(r ** 2 * c) / (4 * l) + 1
	print(s)


t = int(input())
for i in range(t):
	(r, l, c, v) = input().split()
	r = int(r)
	l = int(l)
	c = int(c)
	v = int(v)
	result = 1 - r * r * c / (4 * l)
	print(result)


t = int(input())
for w in range(t):
	yoarr = list(map(int, input().split()))
	r = yoarr[0]
	l = yoarr[1]
	c = yoarr[2]
	vin = yoarr[3]
	print(1 - r ** 2 * c / (4 * l))


t = int(input())
for i in range(t):
	a = [int(i) for i in input().split()]
	r = a[0]
	l = a[1]
	c = a[2]
	vin = a[3]
	ans = r * r * c
	ans = ans / (4 * l)
	ans = 1 - ans
	print(ans)


T = int(input())
for _ in range(T):
	(R, L, C, V) = map(int, input().split())
	answer = 1 - R * R * C / (4 * L)
	print(answer)


t = int(input())
a = lambda x, y, z: -(x * x * z) / (4 * y) + 1
for i in range(t):
	(r, l, c, v) = map(int, input().split())
	print(a(r, l, c))


for i in range(int(input())):
	(r, l, c, vin) = list(map(int, input().split()))
	k = r * r * c / (4 * l)
	print(1 - k)


t = int(input())
while t != 0:
	t -= 1
	numbers = [int(n) for n in input().split()]
	r = numbers[0]
	l = numbers[1]
	c = numbers[2]
	print(1 - r * r * c / (4 * l))


t = int(input())
for test in range(t):
	(r, l, c, v) = map(int, input().split())
	ans = 1
	ans -= r * r * c / (4 * l)
	print('{:.2f}'.format(ans))


for i in range(int(input())):
	(r, l, c, v) = (int(s) for s in input().split())
	print(1 - r ** 2 * c / (4 * l))


t = int(input())
for _ in range(t):
	(r, l, c, vin) = map(int, input().split())
	print(1 - r * r * c / (4 * l))


t = int(input())
for i in range(t):
	s = input()
	(r, l, c, vin) = s.split()
	r = int(r)
	l = int(l)
	c = int(c)
	ans = r * r * c
	ans = ans / 4
	ans = ans / l
	ans *= -1
	ans = ans + 1.0
	print(ans)


for t in range(int(input())):
	(r, l, c, v) = list(map(int, input().split()))
	a = l * c
	b = r * c
	s = -1 * r / (2 * l)
	print(a * s * s + b * s + 1)


t = int(input())
for i in range(t):
	str = input()
	inputs = str.split(' ')
	R = int(inputs[0])
	L = int(inputs[1])
	C = int(inputs[2])
	ans = -1 * C * R * R / (4 * L) + 1
	print(ans)


from sys import stdin, stdout
from math import sqrt
from collections import defaultdict

def preProcess(n=10 ** 6 + 1):
	counter = [0 for i in range(n)]
	for i in range(2, n):
		if counter[i] == 0:
			counter[i] = 1
			for j in range(2 * i, n, i):
				counter[j] += 1
	return counter
t = int(stdin.readline().strip())
while t > 0:
	(R, L, C, Vin) = [float(x) for x in stdin.readline().strip().split()]
	ans = 1 - R / 4 * (R / L) * C
	print(ans)
	t -= 1


for test in range(int(input())):
	(r, l, c, v) = map(int, input().strip().split())
	ans = r * r * c / (4 * l)
	print(1 - ans)


t = int(input())
for i in range(t):
	(r, l, c, v) = [int(x) for x in input().split()]
	kk = c * r * r / (4 * l)
	kk = 1 - kk
	print(round(kk, 2))


from math import *
from itertools import *
T = int(input())
for _ in range(T):
	(R, L, C, V) = map(int, input().split())
	ans = 0
	zz = R ** 2 * C / (4 * L)
	ans = 1 - zz
	print('%.4f' % ans)


t = int(input())
while t > 0:
	t -= 1
	(r, l, c, v) = [int(i) for i in input().split()]
	print(1 - r ** 2 * c / (4 * l))


t = int(input())
a = [[int(s) for s in input().split()] for i in range(t)]
for i in a:
	print(-1 * ((i[0] * i[2]) ** 2 - 4 * i[1] * i[2]) / (4 * i[1] * i[2]))


T = int(input())
for t in range(T):
	(R, L, C, Vin) = [int(x) for x in input().split()]
	print(1 - C * R * R / (4 * L))


t = int(input())
while t != 0:
	(r, l, c, v) = input().split()
	(r, l, v, c) = (int(r), int(l), int(v), int(c))
	ans = 1 - r * r * c / (4 * l)
	print(ans)
	t -= 1


t = int(input())
while t:
	t = t - 1
	arr = list(map(int, input().split()))
	print(1 - arr[0] * arr[0] * arr[2] / (4 * arr[1]))