output_description: Print N lines. The v-th (1 \leq v \leq N) line should contain the answer to
  the following question:
  
    * Assuming that Vertex v has to be black, find the number of ways in which the vertices can be painted, modulo M.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      N M
      x_1 y_1
      x_2 y_2
      :
      x_{N - 1} y_{N - 1}
attempt: class ReRooting:
      """
      0-indexed
      """
  
      def __init__(self, size, root=0, identDp=1, identCum=1):
          """
          identDp: 木DP用 lift(a, identDp) = a
          identCum: 累積用 merge(a, identCum) = a
          """
          self.size = size
          self.edges = [[] for _ in range(self.size + 1)]
          self.root = root
          self.identDp = identDp
          self.identCum = identCum
  
      def addEdge(self, fr, to):
          self.edges[fr].append(to)
          self.edges[to].append(fr)
  
      # 根を固定したときの木DP(貰うDP)
      def lift(self, top, bottom):
          return top * (bottom + 1) % M
  
      # 親の左右の累積から子を根としたときの値を求める
      def merge(self, left, right):
          return left * right % M
  
      def sol(self):
          N = self.size
          edges = self.edges
  
          st = [self.root]
          parent = [-1] * (N + 1)
          child = [[] for _ in range(N + 1)]
          order = []
          while st:
              v = st.pop()
              order.append(v)
              for to in edges[v]:
                  if parent[v] == to:
                      continue
                  parent[to] = v
                  child[v].append(to)
                  st.append(to)
  
          dp = [self.identDp] * (N + 1)
          left = [self.identCum] * (N + 1)
          right = [self.identCum] * (N + 1)
          for v in order[::-1]:  # 貰うDPしつつ，累積をとる
              tmp = self.identCum
              for ch in child[v]:
                  left[ch] = tmp
                  tmp = self.lift(tmp, dp[ch])
              tmp = self.identCum
              for ch in reversed(child[v]):
                  right[ch] = tmp
                  tmp = self.lift(tmp, dp[ch])
              dp[v] = tmp
  
          fromParent = [0] * (N + 1)
          for v in order:
              if v == self.root:
                  continue
              fromParent[v] = self.lift(
                  self.merge(left[v], right[v]), fromParent[parent[v]]
              )
              dp[v] = self.lift(dp[v], fromParent[v])  # 最後に親からの貰うDP
  
          return dp[:N]
  
  
  N, M = map(int, input().split())
  tree = ReRooting(N, 0, 1, 1)
  
  for _ in range(N - 1):
      fr, to = map(int, input().split())
      tree.addEdge(fr - 1, to - 1)
  
  ans = tree.sol()
  print(*ans, sep="\n")
  
problem_description: Statement
  
  There is a tree with N vertices, numbered 1, 2, \ldots, N. For each i (1 \leq
  i \leq N - 1), the i-th edge connects Vertex x_i and y_i.
  
  Taro has decided to paint each vertex in white or black, so that any black
  vertex can be reached from any other black vertex by passing through only
  black vertices.
  
  You are given a positive integer M. For each v (1 \leq v \leq N), answer the
  following question:
  
    * Assuming that Vertex v has to be black, find the number of ways in which the vertices can be painted, modulo M.
samples: [{"input": "3 100\n    1 2\n    2 3", "output": "3\n    4\n    3\n    \n\nThere are seven ways to paint the vertices, as shown in the figure below.\nAmong them, there are three ways such that Vertex 1 is black, four ways such\nthat Vertex 2 is black and three ways such that Vertex 3 is black.\n\n![](https://img.atcoder.jp/dp/subtree_0_muffet.png)\n\n* * *"}, {"input": "4 100\n    1 2\n    1 3\n    1 4", "output": "8\n    5\n    5\n    5\n    \n\n* * *"}, {"input": "1 100", "output": "1\n    \n\n* * *"}, {"input": "10 2\n    8 5\n    10 8\n    6 5\n    1 5\n    4 8\n    2 10\n    3 6\n    9 2\n    1 7", "output": "0\n    0\n    1\n    1\n    1\n    0\n    1\n    0\n    1\n    1\n    \n\nBe sure to print the answers modulo M."}]