Problem:
Score : 600 points

Problem 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).

Constraints

2 \leq N \leq 2 \times 10^5

1 \leq a_i,b_i \leq N

The given graph is a tree.

Input

Input is given from Standard Input in the following format:

N
a_1 b_1
:
a_{N-1} b_{N-1}

Output

For each k=1, 2, ..., N in this order, print a line containing the answer to the problem.

Sample Input 1

3
1 2
1 3

Sample Output 1

2
1
1

The graph in this input is as follows:

For k=1, there are two ways in which we can write the numbers on the vertices, as follows:

Writing 1, 2, 3 on Vertex 1, 2, 3, respectively

Writing 1, 3, 2 on Vertex 1, 2, 3, respectively

Sample Input 2

2
1 2

Sample Output 2

1
1

The graph in this input is as follows:

Sample Input 3

5
1 2
2 3
3 4
3 5

Sample Output 3

2
8
12
3
3

The graph in this input is as follows:

Sample Input 4

8
1 2
2 3
3 4
3 5
3 6
6 7
6 8

Sample Output 4

40
280
840
120
120
504
72
72

The graph in this input is as follows:

Solution in C# (.NET Core 3.1.201) (judge verdict: Accepted)

using System;
using System.Collections.Generic;
using System.Linq;
using System.IO;
using System.Text;
using System.Numerics;
using static System.Math;
using static System.Array;
using static AtCoder.Tool;
namespace AtCoder
{
    class AC
    {
        const int MOD = 1000000007;
        //const int MOD = 998244353;
        const int INF = int.MaxValue / 2;
        const long SINF = long.MaxValue / 2;
        const double EPS = 1e-8;
        static readonly int[] dI = { 0, 1, 0, -1, 1, -1, -1, 1 };
        static readonly int[] dJ = { 1, 0, -1, 0, 1, 1, -1, -1 };
        static List<List<int>> G = new List<List<int>>();
        //static List<List<Edge>> G = new List<List<Edge>>();
        //static List<Edge> E = new List<Edge>();

        static void Main(string[] args)
        {
            var sw = new StreamWriter(Console.OpenStandardOutput()) { AutoFlush = false };
            Console.SetOut(sw);
            var cin = new IO_ShortCut();

            int N = cin.Int;
            for (var i = 0; i < N; i++) G.Add(new List<int>());
            for(var i = 0; i < N - 1; i++)
            {
                int a, b;
                cin.Input(out a, out b);
                a--;
                b--;
                G[a].Add(b);
                G[b].Add(a);
            }
            var md = new Modulo(N, MOD);

            var s = new long[N];
            Initialize(ref s, 0);
            var dp = new long[N];
            Initialize(ref dp, 0);
            var inv = new long[N + 1];
            for (var i = 1; i <= N; i++) inv[i] = md.Div(1, md.Fac(i));


            Func<int, int, long> dfs = null;
            dfs = (v, prev) =>
            {
                long ret = 1;
                var sl = new List<long>();
                foreach(var nx in G[v])
                {
                    if (nx == prev) continue;
                    var ad = s[nx] == 0 ? dfs(nx, v) : s[nx];
                    sl.Add(ad);
                    ret += ad;
                }
                s[v] = ret;
                dp[v] = md.Fac(s[v] - 1);
                foreach(var num in sl)
                {
                    dp[v] = md.Mul(dp[v], inv[num]);
                }
                foreach(var nx in G[v])
                {
                    if (nx != prev) dp[v] = md.Mul(dp[v], dp[nx]);
                }

                return ret;
            };
            var rnd = new Random();

            int root = 0;
            dfs(root, -1);
            //cin.Out_Sep(s);
            //cin.Out_Sep(dp);
            var ans = new long[N];
            Func<int, int, int> dfs2 = null;
            dfs2 = (v, prev) =>
            {
                long ret = md.Fac(N - 1);
                var sl = new List<long>();

                foreach (var nx in G[v])
                {
                    if (nx != prev)
                    {
                        sl.Add(s[nx]);
                        ret = md.Mul(ret, dp[nx]);
                    }
                    else
                    {
                        sl.Add(s[root] - s[v]);
                        long dprev = ans[prev];
                        dprev = md.Mul(dprev, inv[N - 1]);
                        dprev = md.Mul(dprev, md.Fac(s[v]));
                        dprev = md.Mul(dprev, md.Fac(N - 1 - s[v]));
                        dprev = md.Div(dprev, dp[v]);

                        ret = md.Mul(ret, dprev);
                    }
                }
                foreach (var num in sl)
                {
                    ret = md.Mul(ret, inv[num]);
                }
                ans[v] = ret;
                
                foreach (var nx in G[v])
                {
                    if (nx != prev) dfs2(nx, v);
                }
                return 0;
            };
            dfs2(root, -1);
            cin.Out_Sep(ans, "\n");

            Console.Out.Flush();
        }
        struct Edge
        {
            public int from;

            public int to;
            public long dist;
            public Edge(int t, long c)
            {
                from = -1;
                to = t;
                dist = c;
            }
            public Edge(int f, int t, long c)
            {
                from = f;
                to = t;
                dist = c;
            }
        }
    }
    class IO_ShortCut
    {
        public IO_ShortCut() { }
        public string[] ReadSplit => Console.ReadLine().Split();
        public int[] ReadSplitInt => ConvertAll(Console.ReadLine().Split(), int.Parse);
        public long[] ReadSplitLong => ConvertAll(Console.ReadLine().Split(), long.Parse);
        public double[] ReadSplit_Double => ConvertAll(Console.ReadLine().Split(), double.Parse);
        public string Str => Console.ReadLine();
        public int Int => int.Parse(Console.ReadLine());
        public long Long => long.Parse(Console.ReadLine());
        public double Double => double.Parse(Console.ReadLine());
        public T Conv<T>(string input) => (T)Convert.ChangeType(input, typeof(T));
        public void Input<T>(out T a) => a = Conv<T>(Console.ReadLine());
        public void Input<T, U>(out T a, out U b)
        { var q = ReadSplit;a = Conv<T>(q[0]);b = Conv<U>(q[1]); }
        public void Input<T, U, V>(out T a, out U b, out V c)
        { var q = ReadSplit;a = Conv<T>(q[0]);b = Conv<U>(q[1]);c = Conv<V>(q[2]); }
        public void Input<T, U, V, W>(out T a, out U b, out V c, out W d)
        { var q = ReadSplit; a = Conv<T>(q[0]); b = Conv<U>(q[1]); c = Conv<V>(q[2]);d = Conv<W>(q[3]); }

        public void OutL(object s) => Console.WriteLine(s);
        public void Out_Sep<T>(IEnumerable<T> s) => Console.WriteLine(string.Join(" ", s));
        public void Out_Sep<T>(IEnumerable<T> s, string sep) => Console.WriteLine(string.Join($"{sep}", s));
        public void Out_Sep(params object[] s) => Console.WriteLine(string.Join(" ", s));
        public void Out_One(object s) => Console.Write($"{s} ");
        public void Out_One(object s, string sep) => Console.Write($"{s}{sep}");
    }
    public static class Tool
    {
        static public void Initialize<T>(ref T[] array, T initialvalue)
        {
            for (var i = 0; i < array.Length; i++)
            {
                array[i] = initialvalue;
            }
        }
        static public void Swap<T>(ref T a, ref T b)
        {
            T keep = a;
            a = b;
            b = keep;
        }
        static public void Display<T>(T[,] array2d, int n, int m)
        {
            for (var i = 0; i < n; i++)
            {
                for (var j = 0; j < m; j++)
                {
                    Console.Write($"{array2d[i, j]} ");
                }
                Console.WriteLine();
            }
        }
        static public long LPow(int a, int b) => (long)Pow(a, b);
    }
    class Modulo
    {
        private int M;
        private readonly long[] m_facs;
        public long Mul(long a, long b)
        {
            return ((a * b) % M);
        }
        public Modulo(long n, int m)
        {
            M = m;
            m_facs = new long[n + 1];
            m_facs[0] = 1;
            for (long i = 1; i <= n; ++i)
            {
                m_facs[i] = Mul(m_facs[i - 1], i);
            }
        }
        public long Fac(long n)
        {
            return m_facs[n];
        }
        public long Pow(long a, long m)
        {
            switch (m)
            {
                case 0:
                    return 1L;
                case 1:
                    return a;
                default:
                    long p1 = Pow(a, m / 2);
                    long p2 = Mul(p1, p1);
                    return ((m % 2) == 0) ? p2 : Mul(p2, a);
            }
        }
        public long Div(long a, long b)
        {
            return Mul(a, Pow(b, M - 2));
        }
        public long Ncr(long n, long r)
        {
            if (n < r) { return 0; }
            if (n == r) { return 1; }
            long res = Fac(n);
            res = Div(res, Fac(r));
            res = Div(res, Fac(n - r));
            return res;
        }
    }
}