output_description: In i-th (1 ≤ i ≤ N) line, print the expected vaule of the number of turns
  E869120 moves.  
  The relative error or absolute error of output should be within 10^{-6}.
input_description: The input is given from standard input in the following format.  
    
  
      
      
      N
      u_1 v_1
      u_2 v_2
       :
      u_{N-1} v_{N-1}
attempt: class Tree:
      def __init__(self, n, edge):
          self.n = n
          self.tree = [[] for _ in range(n)]
          for e in edge:
              self.tree[e[0] - 1].append(e[1] - 1)
              self.tree[e[1] - 1].append(e[0] - 1)
  
      def setroot(self, root):
          self.root = root
          self.parent = [None for _ in range(self.n)]
          self.parent[root] = -1
          self.depth = [None for _ in range(self.n)]
          self.depth[root] = 0
          self.order = []
          self.order.append(root)
          stack = [root]
          while stack:
              node = stack.pop()
              for adj in self.tree[node]:
                  if self.parent[adj] is None:
                      self.parent[adj] = node
                      self.depth[adj] = self.depth[node] + 1
                      self.order.append(adj)
                      stack.append(adj)
  
      def rerooting(self, func, merge, ti, ei):
          dp = [ti for _ in range(self.n)]
          lt = [ei for _ in range(self.n)]
          rt = [ei for _ in range(self.n)]
          inv = [ei for _ in range(self.n)]
          self.setroot(0)
          for node in self.order[::-1]:
              tmp = ti
              for adj in self.tree[node]:
                  if self.parent[adj] == node:
                      lt[adj] = tmp
                      tmp = func(tmp, dp[adj])
              tmp = ti
              for adj in self.tree[node][::-1]:
                  if self.parent[adj] == node:
                      rt[adj] = tmp
                      tmp = func(tmp, dp[adj])
              dp[node] = tmp
          for node in self.order:
              if node == 0:
                  continue
              merged = merge(lt[node], rt[node])
              par = self.parent[node]
              inv[node] = func(merged, inv[par])
              dp[node] = func(dp[node], inv[node])
          return dp
  
  
  import sys
  
  input = sys.stdin.readline
  
  N = int(input())
  E = [tuple(map(int, input().split())) for _ in range(N - 1)]
  
  T = Tree(N, E)
  
  
  def func(node, adj):
      size = node[1] + 1
      exp = (node[0] * node[1] + adj[0] + 1) / size if size else 0
      return exp, size
  
  
  def merge(lt, rt):
      size = lt[1] + rt[1]
      exp = (lt[0] * lt[1] + rt[0] * rt[1]) / size if size else 0
      return exp, size
  
  
  ti = (0, 0)
  ei = (-1, 0)
  
  D = T.rerooting(func, merge, ti, ei)
  
  res = []
  
  for i in range(N):
      res.append(D[i][0])
  
  print("\n".join(map(str, res)))
  
problem_description: Statement
  
  There is an undirected connected graph with $N$ vertices and $N-1$ edges. The
  i-th edge connects u_i and v_i.  
    
  E869120 the coder moves in the graph as follows:  
  
    * He move to adjacent vertex, but he can't a visit vertex two or more times.
    * He ends move when there is no way to move.
    * Otherwise, he moves randomly. (equal probability) If he has $p$ way to move this turn, he choose each vertex with $1/p$ probability.
  
  ![](https://atcoder.jp/img/s8pc-4/5973dad11843e9098d9225dd431c9084.png)
  
  Calculate the expected value of the number of turns, when E869120 starts from
  vertex i, for all i (1 ≤ i ≤ N).
samples: [{"input": "4\n    1 2\n    2 3\n    2 4", "output": "2.0\n    1.0\n    2.0\n    2.0"}]