import sys

sys.setrecursionlimit(2147483647)

INF=float("inf")

MOD=10**9+7 # 998244353

input=lambda:sys.stdin.readline().rstrip()

def resolve():

    n, MOD = map(int,input().split())

    if n == 1:

        print(1)

        return



    E = [[] for _ in range(n)]

    nv_to_idx = [{} for _ in range(n)]

    for _ in range(n - 1):

        u, v = map(int,input().split())

        u -= 1; v -= 1

        nv_to_idx[u][v] = len(E[u])

        nv_to_idx[v][u] = len(E[v])

        E[u].append(v)

        E[v].append(u)



    # tree DP

    dp = [1] * n

    deg = [len(E[v]) - 1 for v in range(n)]

    deg[0] += 1

    stack = [(0, -1)]

    while stack:

        v, p = stack.pop()

        if v >= 0:

            for nv in E[v]:

                if nv == p:

                    continue

                stack.append((~nv, v))

                stack.append((nv, v))

        else:

            if deg[~v] == 0:

                dp[p] = dp[p] * (dp[~v] + 1) % MOD

            deg[p] -= 1



    # rerooting

    def rerooting(v, p):

        # p-rooted -> dp[p] を v-rooted に modify

        if p != -1:

            idx = nv_to_idx[p][v]

            p_res = 1

            if idx > 0:

                p_res *= cum_left[p][idx - 1]

            if idx < len(E[p]) - 1:

                p_res *= cum_right[p][idx + 1]

            dp[p] = p_res % MOD



        # monoid に対する cumulative sum を計算

        if cum_left[v] is None:

            left = [(dp[nv] + 1) % MOD for nv in E[v]]

            right = [(dp[nv] + 1) % MOD for nv in E[v]]

            k = len(E[v])

            for i in range(k - 1):

                left[i + 1] *= left[i]

                left[i + 1] %= MOD

            for i in range(k - 1, 0, -1):

                right[i - 1] *= right[i]

                right[i - 1] %= MOD

            cum_left[v] = left

            cum_right[v] = right

        dp[v] = cum_left[v][-1]



    ans = [None] * n

    stack = [(0, -1)]

    cum_left = [None] * n

    cum_right = [None] * n

    while stack:

        v, p = stack.pop()

        if v >= 0:

            rerooting(v, p)

            ans[v] = dp[v]

            for nv in E[v]:

                if nv == p:

                    continue

                stack.append((~nv, v))

                stack.append((nv, v))

        else:

            rerooting(p, ~v)



    print(*ans, sep = '\n')

resolve()

import sys

sys.setrecursionlimit(2147483647)

INF=float("inf")

MOD=10**9+7 # 998244353

input=lambda:sys.stdin.readline().rstrip()

def resolve():

    n, MOD = map(int,input().split())

    E = [[] for _ in range(n)]

    nv_to_idx = [{} for _ in range(n)]

    for _ in range(n - 1):

        u, v = map(int,input().split())

        u -= 1; v -= 1

        nv_to_idx[u][v] = len(E[u])

        nv_to_idx[v][u] = len(E[v])

        E[u].append(v)

        E[v].append(u)



    # tree DP

    dp = [1] * n

    deg = [len(E[v]) - 1 for v in range(n)]

    deg[0] += 1

    stack = [(0, -1)]

    while stack:

        v, p = stack.pop()

        if v >= 0:

            for nv in E[v]:

                if nv == p:

                    continue

                stack.append((~nv, v))

                stack.append((nv, v))

        else:

            if deg[~v] == 0:

                dp[p] = dp[p] * (dp[~v] + 1) % MOD

            deg[p] -= 1



    # rerooting

    def rerooting(v, p):

        # p-rooted -> dp[p] を v-rooted に modify

        if p != -1:

            idx = nv_to_idx[p][v]

            dp[p] = cum_left[p][idx] * cum_right[p][idx + 1] % MOD



        # monoid に対する cumulative sum を計算

        if cum_left[v] is None:

            k = len(E[v])

            left = [1] * (k + 1)

            right = [1] * (k + 1)

            for i in range(k):

                left[i + 1] = left[i] * (dp[E[v][i]] + 1) % MOD

            for i in range(k - 1, -1, -1):

                right[i] = right[i + 1] * (dp[E[v][i]] + 1) % MOD

            cum_left[v] = left

            cum_right[v] = right



        # dp[v] を v-rooted に modify

        dp[v] = cum_left[v][-1]



    ans = [None] * n

    stack = [(0, -1)]

    cum_left = [None] * n

    cum_right = [None] * n

    while stack:

        v, p = stack.pop()

        if v >= 0:

            rerooting(v, p)

            ans[v] = dp[v]

            for nv in E[v]:

                if nv == p:

                    continue

                stack.append((~nv, v))

                stack.append((nv, v))

        else:

            rerooting(p, ~v)



    print(*ans, sep = '\n')

resolve()

import sys

sys.setrecursionlimit(2147483647)
INF = float("inf")
MOD = 10**9 + 7  # 998244353
input = lambda: sys.stdin.readline().rstrip()


def resolve():
    n, MOD = map(int, input().split())
    if n == 1:
        print(1)
        return
    E = [[] for _ in range(n)]
    nv_to_idx = [{} for _ in range(n)]
    for _ in range(n - 1):
        u, v = map(int, input().split())
        u -= 1
        v -= 1
        nv_to_idx[u][v] = len(E[u])
        nv_to_idx[v][u] = len(E[v])
        E[u].append(v)
        E[v].append(u)
    # tree DP
    dp = [1] * n
    deg = [len(E[v]) - 1 for v in range(n)]
    deg[0] += 1
    stack = [(0, -1)]
    while stack:
        v, p = stack.pop()
        if v >= 0:
            for nv in E[v]:
                if nv == p:
                    continue
                stack.append((~nv, v))
                stack.append((nv, v))
        else:
            if deg[~v] == 0:
                dp[p] = dp[p] * (dp[~v] + 1) % MOD
            deg[p] -= 1
    # rerooting
    def rerooting(v, p):
        # p-rooted -> dp[p] を v-rooted に modify
        if p != -1:
            idx = nv_to_idx[p][v]
            p_res = 1
            if idx > 0:
                p_res *= cum_left[p][idx - 1]
            if idx < len(E[p]) - 1:
                p_res *= cum_right[p][idx + 1]
            dp[p] = p_res % MOD
        # monoid に対する cumulative sum を計算
        if cum_left[v] is None:
            left = [(dp[nv] + 1) % MOD for nv in E[v]]
            right = [(dp[nv] + 1) % MOD for nv in E[v]]
            k = len(E[v])
            for i in range(k - 1):
                left[i + 1] *= left[i]
                left[i + 1] %= MOD
            for i in range(k - 1, 0, -1):
                right[i - 1] *= right[i]
                right[i - 1] %= MOD
            cum_left[v] = left
            cum_right[v] = right
        dp[v] = cum_left[v][-1]

    ans = [None] * n
    stack = [(0, -1)]
    cum_left = [None] * n
    cum_right = [None] * n
    while stack:
        v, p = stack.pop()
        if v >= 0:
            rerooting(v, p)
            ans[v] = dp[v]
            for nv in E[v]:
                if nv == p:
                    continue
                stack.append((~nv, v))
                stack.append((nv, v))
        else:
            rerooting(p, ~v)
    print(*ans, sep="\n")


resolve()

import sys

sys.setrecursionlimit(2147483647)
INF = float("inf")
MOD = 10**9 + 7  # 998244353
input = lambda: sys.stdin.readline().rstrip()


def resolve():
    n, MOD = map(int, input().split())
    E = [[] for _ in range(n)]
    nv_to_idx = [{} for _ in range(n)]
    for _ in range(n - 1):
        u, v = map(int, input().split())
        u -= 1
        v -= 1
        nv_to_idx[u][v] = len(E[u])
        nv_to_idx[v][u] = len(E[v])
        E[u].append(v)
        E[v].append(u)
    # tree DP
    dp = [1] * n
    deg = [len(E[v]) - 1 for v in range(n)]
    deg[0] += 1
    stack = [(0, -1)]
    while stack:
        v, p = stack.pop()
        if v >= 0:
            for nv in E[v]:
                if nv == p:
                    continue
                stack.append((~nv, v))
                stack.append((nv, v))
        else:
            if deg[~v] == 0:
                dp[p] = dp[p] * (dp[~v] + 1) % MOD
            deg[p] -= 1
    # rerooting
    def rerooting(v, p):
        # p-rooted -> dp[p] を v-rooted に modify
        if p != -1:
            idx = nv_to_idx[p][v]
            dp[p] = cum_left[p][idx] * cum_right[p][idx + 1] % MOD
        # monoid に対する cumulative sum を計算
        if cum_left[v] is None:
            k = len(E[v])
            left = [1] * (k + 1)
            right = [1] * (k + 1)
            for i in range(k):
                left[i + 1] = left[i] * (dp[E[v][i]] + 1) % MOD
            for i in range(k - 1, -1, -1):
                right[i] = right[i + 1] * (dp[E[v][i]] + 1) % MOD
            cum_left[v] = left
            cum_right[v] = right
        # dp[v] を v-rooted に modify
        dp[v] = cum_left[v][-1]

    ans = [None] * n
    stack = [(0, -1)]
    cum_left = [None] * n
    cum_right = [None] * n
    while stack:
        v, p = stack.pop()
        if v >= 0:
            rerooting(v, p)
            ans[v] = dp[v]
            for nv in E[v]:
                if nv == p:
                    continue
                stack.append((~nv, v))
                stack.append((nv, v))
        else:
            rerooting(p, ~v)
    print(*ans, sep="\n")


resolve()

-    if n == 1: -        print(1) -        return -            p_res = 1 -            if idx > 0: -                p_res *= cum_left[p][idx - 1] -            if idx < len(E[p]) - 1: -                p_res *= cum_right[p][idx + 1] -            dp[p] = p_res % MOD +            dp[p] = cum_left[p][idx] * cum_right[p][idx + 1] % MOD -            left = [(dp[nv] + 1) % MOD for nv in E[v]] -            right = [(dp[nv] + 1) % MOD for nv in E[v]] -            for i in range(k - 1): -                left[i + 1] *= left[i] -                left[i + 1] %= MOD -            for i in range(k - 1, 0, -1): -                right[i - 1] *= right[i] -                right[i - 1] %= MOD +            left = [1] * (k + 1) +            right = [1] * (k + 1) +            for i in range(k): +                left[i + 1] = left[i] * (dp[E[v][i]] + 1) % MOD +            for i in range(k - 1, -1, -1): +                right[i] = right[i + 1] * (dp[E[v][i]] + 1) % MOD +        # dp[v] を v-rooted に modify