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: from sys import setrecursionlimit
  from math import factorial
  
  setrecursionlimit(2 * 10**5)
  
  
  def comb(n, r):
      return factorial(n) / factorial(r) / factorial(n - r)
  
  
  class Node:
      def __init__(self, node_id):
          self.id = node_id
          self.children = []
          self.size = 1
  
      def add_child(self, node):
          self.children.append(node)
  
      @staticmethod
      def prepare_nodes(n):
          nodes = tuple([Node(i) for i in range(n)])
          for _ in range(n - 1):
              a, b = sorted(map(lambda x: int(x) - 1, input().split()))
              nodes[a].add_child(nodes[b])
  
          return nodes
  
  
  def main():
      n = int(input())
      nodes = Node.prepare_nodes(n)
  
      dp = [0] * n
  
      def f(node):
          dpv = 1
          denominator = 1
          for child in node.children:
              f(child)
              dpv *= dp[child.id]
              denominator *= factorial(child.size)
              node.size += child.size
  
          dpv *= factorial(node.size - 1) // denominator
  
          dp[node.id] = dpv
  
      f(nodes[0])
  
      def g(node, parent):
          if parent:
              parent_dp = dp[parent.id]
              parent_dp = parent_dp // (dp[node.id] * int(comb(n - 1, node.size)))
  
              dp[node.id] *= parent_dp * int(comb(n - 1, n - node.size))
  
          for child in node.children:
              g(child, node)
  
      g(nodes[0], None)
  
      for ans in dp:
          print(ans)
  
  
  main()
  
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)"}]