output_description: For each k=1, 2, ..., N in this order, print a line containing the answer to
  the problem.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      N
      a_1 b_1
      :
      a_{N-1} b_{N-1}
attempt: import sys
  
  input = sys.stdin.readline
  
  from collections import deque
  
  MOD = 10**9 + 7
  INF = float("inf")
  
  
  def inv(n):
      return pow(n, MOD - 2, MOD)
  
  
  kaijo_memo = []
  
  
  def kaijo(n):
      if len(kaijo_memo) > n:
          return kaijo_memo[n]
      if len(kaijo_memo) == 0:
          kaijo_memo.append(1)
      while len(kaijo_memo) <= n:
          kaijo_memo.append(kaijo_memo[-1] * len(kaijo_memo) % MOD)
      return kaijo_memo[n]
  
  
  gyaku_kaijo_memo = []
  
  
  def gyaku_kaijo(n):
      if len(gyaku_kaijo_memo) > n:
          return gyaku_kaijo_memo[n]
      if len(gyaku_kaijo_memo) == 0:
          gyaku_kaijo_memo.append(1)
      while len(gyaku_kaijo_memo) <= n:
          gyaku_kaijo_memo.append(
              gyaku_kaijo_memo[-1] * pow(len(gyaku_kaijo_memo), MOD - 2, MOD) % MOD
          )
      return gyaku_kaijo_memo[n]
  
  
  def nCr(n, r):
      if n == r:
          return 1
      if n < r or r < 0:
          return 0
      ret = 1
      ret = ret * kaijo(n) % MOD
      ret = ret * gyaku_kaijo(r) % MOD
      ret = ret * gyaku_kaijo(n - r) % MOD
      return ret
  
  
  N = int(input())
  graph = [[] for i in range(N)]
  for _ in range(N - 1):
      a, b = list(map(int, input().split()))
      graph[a - 1].append(b - 1)
      graph[b - 1].append(a - 1)
  
  p = [-1 for i in range(N)]
  a = [[] for i in range(N)]
  
  shori = []
  
  
  def bfs(graph, start):
      N = len(graph)
      d = [INF] * N
      d[start] = 0
      q = deque([start])
      while q:
          u = q.popleft()
          shori.append(u)
          for v in graph[u]:
              if d[v] != INF:
                  continue
              d[v] = d[u] + 1
              p[v] = u
              a[u].append(v)
              q.append(v)
      return d
  
  
  bfs(graph, 0)
  
  size = [0 for i in range(N)]
  
  
  def calc_size(x):
      if size[x]:
          return size[x]
      temp = 1
      for y in a[x]:
          temp += calc_size(y)
      size[x] = temp
      return size[x]
  
  
  calc_size(0)
  
  narabi = [0 for i in range(N)]
  
  
  def calc_narabi(x):
      if narabi[x]:
          return narabi[x]
      temp = kaijo(size[x] - 1)
      for y in a[x]:
          temp *= gyaku_kaijo(size[y]) * calc_narabi(y)
          temp %= MOD
      narabi[x] = temp
      return narabi[x]
  
  
  calc_narabi(0)
  
  
  pnarabi = [1 for i in range(N)]
  for i in shori[1:]:
      pnarabi[i] = (
          narabi[p[i]]
          * inv(narabi[i])
          * inv(nCr(size[p[i]] - 1, size[i]))
          * pnarabi[p[i]]
          * nCr(N - 1 - size[i], N - size[p[i]])
      )
      pnarabi[i] %= MOD
  
  for i in shori[1:]:
      temp = narabi[i] * nCr(N - 1, size[i] - 1) * pnarabi[i]
      temp %= MOD
      narabi[i] = temp
  
  print(*narabi, sep="\n")
  
problem_description: Statement
  
  We have a tree with N vertices numbered 1 to N. The i-th edge in this tree
  connects Vertex a_i and b_i. For each k=1, ..., N, solve the problem below:
  
    * Consider writing a number on each vertex in the tree in the following manner:
      * First, write 1 on Vertex k.
      * Then, for each of the numbers 2, ..., N in this order, write the number on the vertex chosen as follows:
        * Choose a vertex that still does not have a number written on it and is adjacent to a vertex with a number already written on it. If there are multiple such vertices, choose one of them at random.
    * Find the number of ways in which we can write the numbers on the vertices, modulo (10^9+7).
samples: [{"input": "3\n    1 2\n    1 3", "output": "2\n    1\n    1\n    \n\nThe graph in this input is as follows:\n\n![Figure](https://img.atcoder.jp/ghi/1c88b0eb716ba399b1c5d6565ab62337.png)\n\nFor k=1, there are two ways in which we can write the numbers on the vertices,\nas follows:\n\n  * Writing 1, 2, 3 on Vertex 1, 2, 3, respectively\n  * Writing 1, 3, 2 on Vertex 1, 2, 3, respectively\n\n* * *"}, {"input": "2\n    1 2", "output": "1\n    1\n    \n\nThe graph in this input is as follows:\n\n![Figure](https://img.atcoder.jp/ghi/c47c7798f88e7bfec30fbd664dc9ad50.png)\n\n* * *"}, {"input": "5\n    1 2\n    2 3\n    3 4\n    3 5", "output": "2\n    8\n    12\n    3\n    3\n    \n\nThe graph in this input is as follows:\n\n![Figure](https://img.atcoder.jp/ghi/e9c09403f8d96ae4e679a226993defa6.png)\n\n* * *"}, {"input": "8\n    1 2\n    2 3\n    3 4\n    3 5\n    3 6\n    6 7\n    6 8", "output": "40\n    280\n    840\n    120\n    120\n    504\n    72\n    72\n    \n\nThe graph in this input is as follows:\n\n![Figure](https://img.atcoder.jp/ghi/a85459a03d436560bfe2e911d8cec4e6.png)"}]