Problem: After defeating a Blacklist Rival, you get a chance to draw 1 reward slip out of x hidden valid slips. Initially, x=3 and these hidden valid slips are Cash Slip, Impound Strike Release Marker and Pink Slip of Rival's Car. Initially, the probability of drawing these in a random guess are c, m, and p, respectively. There is also a volatility factor v. You can play any number of Rival Races as long as you don't draw a Pink Slip. Assume that you win each race and get a chance to draw a reward slip. In each draw, you draw one of the x valid items with their respective probabilities. Suppose you draw a particular item and its probability of drawing before the draw was a. Then,

  * If the item was a Pink Slip, the quest is over, and you will not play any more races. 
  * Otherwise, 
    1. If a≤ v, the probability of the item drawn becomes 0 and the item is no longer a valid item for all the further draws, reducing x by 1. Moreover, the reduced probability a is distributed equally among the other remaining valid items. 
    2. If a > v, the probability of the item drawn reduces by v and the reduced probability is distributed equally among the other valid items. 



For example,

  * If (c,m,p)=(0.2,0.1,0.7) and v=0.1, after drawing Cash, the new probabilities will be (0.1,0.15,0.75). 
  * If (c,m,p)=(0.1,0.2,0.7) and v=0.2, after drawing Cash, the new probabilities will be (Invalid,0.25,0.75). 
  * If (c,m,p)=(0.2,Invalid,0.8) and v=0.1, after drawing Cash, the new probabilities will be (0.1,Invalid,0.9). 
  * If (c,m,p)=(0.1,Invalid,0.9) and v=0.2, after drawing Cash, the new probabilities will be (Invalid,Invalid,1.0). 



You need the cars of Rivals. So, you need to find the expected number of races that you must play in order to draw a pink slip.

Input

The first line of input contains a single integer t (1≤ t≤ 10) — the number of test cases.

The first and the only line of each test case contains four real numbers c, m, p and v (0 < c,m,p < 1, c+m+p=1, 0.1≤ v≤ 0.9).

Additionally, it is guaranteed that each of c, m, p and v have at most 4 decimal places.

Output

For each test case, output a single line containing a single real number — the expected number of races that you must play in order to draw a Pink Slip.

Your answer is considered correct if its absolute or relative error does not exceed 10^{-6}.

Formally, let your answer be a, and the jury's answer be b. Your answer is accepted if and only if \frac{|a - b|}{max{(1, |b|)}} ≤ 10^{-6}.

Example

Input


4
0.2 0.2 0.6 0.2
0.4 0.2 0.4 0.8
0.4998 0.4998 0.0004 0.1666
0.3125 0.6561 0.0314 0.2048


Output


1.532000000000
1.860000000000
5.005050776521
4.260163673896

Note

For the first test case, the possible drawing sequences are: 

  * P with a probability of 0.6; 
  * CP with a probability of 0.2⋅ 0.7 = 0.14; 
  * CMP with a probability of 0.2⋅ 0.3⋅ 0.9 = 0.054; 
  * CMMP with a probability of 0.2⋅ 0.3⋅ 0.1⋅ 1 = 0.006; 
  * MP with a probability of 0.2⋅ 0.7 = 0.14; 
  * MCP with a probability of 0.2⋅ 0.3⋅ 0.9 = 0.054; 
  * MCCP with a probability of 0.2⋅ 0.3⋅ 0.1⋅ 1 = 0.006. 

So, the expected number of races is equal to 1⋅ 0.6 + 2⋅ 0.14 + 3⋅ 0.054 + 4⋅ 0.006 + 2⋅ 0.14 + 3⋅ 0.054 + 4⋅ 0.006 = 1.532.

For the second test case, the possible drawing sequences are: 

  * P with a probability of 0.4; 
  * CP with a probability of 0.4⋅ 0.6 = 0.24; 
  * CMP with a probability of 0.4⋅ 0.4⋅ 1 = 0.16; 
  * MP with a probability of 0.2⋅ 0.5 = 0.1; 
  * MCP with a probability of 0.2⋅ 0.5⋅ 1 = 0.1. 



So, the expected number of races is equal to 1⋅ 0.4 + 2⋅ 0.24 + 3⋅ 0.16 + 2⋅ 0.1 + 3⋅ 0.1 = 1.86.

Solution (in PYTHON3):

Solution:
import sys,os
from io import BytesIO,IOBase
# from functools import lru_cache
mod = 10**9+7; Mod = 998244353; INF = float('inf')
# input = lambda: sys.stdin.readline().rstrip("\r\n")
# inp = lambda: list(map(int,sys.stdin.readline().rstrip("\r\n").split()))
#______________________________________________________________________________________________________
# region fastio
# ''' 
BUFSIZE = 8192
class FastIO(IOBase):
    newlines = 0
    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None
    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()
    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()
    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
# endregion'''
#______________________________________________________________________________________________________
input = lambda: sys.stdin.readline().rstrip("\r\n")
inp = lambda: list(map(int,sys.stdin.readline().rstrip("\r\n").split()))
# ______________________________________________________________________________________________________
# import math
# from bisect import *
# from heapq import *
# from collections import defaultdict as dd
# from collections import OrderedDict as odict
# from collections import Counter as cc
# from collections import deque
# from itertools import groupby
# from itertools import combinations
# sys.setrecursionlimit(100_100) #this is must for dfs
# ______________________________________________________________________________________________________
# segment tree for range minimum query and update 0 indexing
# init = float('inf')
# st = [init for i in range(4*len(a))]
# def build(a,ind,start,end):
#     if start == end:
#         st[ind] = a[start]
#     else:
#         mid = (start+end)//2
#         build(a,2*ind+1,start,mid)
#         build(a,2*ind+2,mid+1,end)
#         st[ind] = min(st[2*ind+1],st[2*ind+2])
# build(a,0,0,n-1)
# def query(ind,l,r,start,end):
#     if start>r or end<l:
#         return init
#     if l<=start<=end<=r:
#         return st[ind]
#     mid = (start+end)//2
#     return min(query(2*ind+1,l,r,start,mid),query(2*ind+2,l,r,mid+1,end))
# def update(ind,val,stind,start,end):
#   if start<=ind<=end:
#       if start==end:
#           st[stind] = a[start] = val
#       else:
#           mid = (start+end)//2
#           update(ind,val,2*stind+1,start,mid)
#           update(ind,val,2*stind+2,mid+1,end)
#           st[stind] = min(st[left],st[right])
# ______________________________________________________________________________________________________
# Checking prime in O(root(N))
# def isprime(n):
#     if (n % 2 == 0 and n > 2) or n == 1: return 0
#     else:
#         s = int(n**(0.5)) + 1
#         for i in range(3, s, 2):
#             if n % i == 0:
#                 return 0
#         return 1
# def lcm(a,b):
#   return (a*b)//gcd(a,b)
# returning factors in O(root(N))
# def factors(n):
#     fact = []
#     N = int(n**0.5)+1
#     for i in range(1,N):
#         if (n%i==0):
#             fact.append(i)
#             if (i!=n//i):
#                 fact.append(n//i)
#     return fact
# ______________________________________________________________________________________________________
# Merge sort for inversion count
# def mergeSort(left,right,arr,temp):
#     inv_cnt = 0
#     if left<right:
#         mid = (left+right)//2
#         inv1 = mergeSort(left,mid,arr,temp)
#         inv2 = mergeSort(mid+1,right,arr,temp)
#         inv3 = merge(left,right,mid,arr,temp)
#         inv_cnt = inv1+inv3+inv2
#     return inv_cnt
# def merge(left,right,mid,arr,temp):
#     i = left
#     j = mid+1
#     k = left
#     inv = 0
#     while(i<=mid and j<=right):
#         if(arr[i]<=arr[j]):
#             temp[k] = arr[i]
#             i+=1
#         else:
#             temp[k] = arr[j]
#             inv+=(mid+1-i)
#             j+=1
#         k+=1
#     while(i<=mid):
#         temp[k]=arr[i]
#         i+=1
#         k+=1
#     while(j<=right):
#         temp[k]=arr[j]
#         j+=1
#         k+=1
#     for k in range(left,right+1):
#         arr[k] = temp[k]
#     return inv
# ______________________________________________________________________________________________________
# nCr under mod
# def C(n,r,mod = 10**9+7):
#   if r>n: return 0
#   if r>n-r: r = n-r
#   num = den = 1
#   for i in range(r):
#       num = (num*(n-i))%mod
#       den = (den*(i+1))%mod
#   return (num*pow(den,mod-2,mod))%mod
# def C(n,r):
#   if r>n:
#       return 0
#   if r>n-r:
#       r = n-r
#   ans = 1
#   for i in range(r):
#       ans = (ans*(n-i))//(i+1)
#   return ans
# ______________________________________________________________________________________________________
# For smallest prime factor of a number
# M = 5*10**5+100
# spf = [i for i in range(M)]
# def spfs(M):
#     for i in range(2,M):
#         if spf[i]==i:
#             for j in range(i*i,M,i):
#                 if spf[j]==j:
#                     spf[j] = i

#     return
# spfs(M)
# p = [0]*M
# for i in range(2,M):
#     p[i]+=(p[i-1]+(spf[i]==i))
# ______________________________________________________________________________________________________
# def gtc(p):
#     print('Case #'+str(p)+': ',end='')
# ______________________________________________________________________________________________________
tc = 1
tc = int(input())
for test in range(1,tc+1):
    c,m,p,v = map(float,input().split())
    error = 10**(-8)
    def solve(c,m,p,g):
        if c<=error:
            c = 0
        if m<=error:
            m = 0
        ans = 0
        if c!=0:
            if (c<=v):
                if (m==0):
                    ans+= c*solve(0,0,p+c,g+1)
                else:
                    ans+=c*solve(0,m+c/2,p+c/2,g+1)
            else:
                if (m==0):
                    ans+=c*solve(c-v,0,p+v,g+1)
                else:
                    ans+=c*solve(c-v,m+v/2,p+v/2,g+1)
        if m!=0:
            if (c==0):
                if (m<=v):
                    ans+=m*solve(0,0,p+m,g+1)
                else:
                    ans+=m*solve(0,m-v,p+v,g+1)
            else:
                if (m<=v):
                    ans+=m*solve(c+m/2,0,p+m/2,g+1)
                else:
                    ans+=m*solve(c+v/2,m-v,p+v/2,g+1)
        ans+= p*g
        return ans

    ans = solve(c,m,p,1)
    print(ans)