Consider a tree $T$ (that is, a connected graph without cycles) with $n$ vertices labelled $1$ through $n$. We start the following process with $T$: while $T$ has more than one vertex, do the following:



 choose a random edge of $T$ equiprobably;

 shrink the chosen edge: if the edge was connecting vertices $v$ and $u$, erase both $v$ and $u$ and create a new vertex adjacent to all vertices previously adjacent to either $v$ or $u$. The new vertex is labelled either $v$ or $u$ equiprobably.

At the end of the process, $T$ consists of a single vertex labelled with one of the numbers $1, \ldots, n$. For each of the numbers, what is the probability of this number becoming the label of the final vertex?


-----Input-----

The first line contains a single integer $n$ ($1 \leq n \leq 50$).

The following $n - 1$ lines describe the tree edges. Each of these lines contains two integers $u_i, v_i$ — labels of vertices connected by the respective edge ($1 \leq u_i, v_i \leq n$, $u_i \neq v_i$). It is guaranteed that the given graph is a tree.


-----Output-----

Print $n$ floating numbers — the desired probabilities for labels $1, \ldots, n$ respectively. All numbers should be correct up to $10^{-6}$ relative or absolute precision.


-----Examples-----
Input
4
1 2
1 3
1 4

Output
0.1250000000
0.2916666667
0.2916666667
0.2916666667

Input
7
1 2
1 3
2 4
2 5
3 6
3 7

Output
0.0850694444
0.0664062500
0.0664062500
0.1955295139
0.1955295139
0.1955295139
0.1955295139



-----Note-----

In the first sample, the resulting vertex has label 1 if and only if for all three edges the label 1 survives, hence the probability is $1/2^3 = 1/8$. All other labels have equal probability due to symmetry, hence each of them has probability $(1 - 1/8) / 3 = 7/24$.

```python

USER_FILENAME = "<user_code>"
import sys, json, builtins
import math, heapq, bisect, itertools, functools, collections, statistics, fractions, decimal, operator, array, random, re, string, os, pathlib
try:
    import resource as _res
except Exception:
    _res = None
from collections import Counter, defaultdict, deque, OrderedDict
from functools import lru_cache, reduce
from itertools import accumulate, permutations, combinations, product
from math import gcd, ceil, floor, sqrt
from decimal import Decimal
try:
    from typing import *
except Exception:
    pass
try:
    sys.setrecursionlimit(1_000_000)
except Exception:
    pass
try:
    import site as _site
    try:
        _sys_sites = _site.getsitepackages() if hasattr(_site, "getsitepackages") else []
        for _p in _sys_sites:
            if _p and _p not in sys.path:
                sys.path.append(_p)
    except Exception:
        pass
    try:
        _usp = _site.getusersitepackages()
        if isinstance(_usp, str):
            _usp = [_usp]
        for _p in _usp:
            if _p and _p not in sys.path:
                sys.path.append(_p)
    except Exception:
        pass
except Exception:
    pass

ns = {"__name__": "__main__"}
for _k, _v in list(globals().items()):
    if not _k.startswith("_"):
        ns[_k] = _v
_CODE = 'maxn=50+10\ng=[None]*maxn\ndp=[None]*maxn\nc=[None]*maxn\nsize=[0]*maxn\n\nfor i in range(0,maxn):\n    c[i]=[0]*maxn\n    c[i][0]=1\n    for j in range(1,i+1):\n        c[i][j]=c[i-1][j-1]+c[i-1][j]\n\nn=int(input())\nfor i in range(1,n+1):\n    g[i]=[]\nfor i in range(1,n):\n    u,v=input().split()\n    u=int(u)\n    v=int(v)\n    g[u].append(v)\n    g[v].append(u)\n\ndef mul(a,b,x,y):\n    tmp=[0]*(x+y+1)\n    for i in range(0,x+1):\n        for j in range(0,y+1):\n            tmp[i+j]+=a[i]*b[j]*c[i+j][i]*c[x+y-i-j][x-i]\n    return tmp\ndef dfs(pos,fa):\n    nonlocal dp\n    nonlocal size\n    dp[pos]=[1]\n    size[pos]=0\n    for ch in g[pos]:\n        if ch != fa:\n            dfs(pos=ch,fa=pos)\n            dp[pos]=mul(dp[pos],dp[ch],size[pos],size[ch])\n            size[pos]+=size[ch]\n    if fa:\n        size[pos]+=1\n        tmp=[0]*(size[pos]+1)\n        for i in range(0,size[pos]+1):\n            for j in range(0,size[pos]):\n                if j<i:\n                    tmp[i]+=dp[pos][i-1]\n                else:\n                    tmp[i]+=dp[pos][j]*0.5\n        dp[pos]=tmp\n\nfor i in range(1,n+1):\n    dfs(pos=i,fa=0)\n    tmp=dp[i][0]\n    for j in range(1,n):\n        tmp/=j\n    print(tmp)'
_co = compile(_CODE, USER_FILENAME, "exec")
exec(_co, ns, ns)

```

Measured memory_bytes: