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# (Mono 4.6.2.0) (judge verdict: Runtime Error)

#region いつもの
using System;
using System.Collections.Generic;
using System.Linq;
using IEnumerable = System.Collections.IEnumerable;
using IEnumerator = System.Collections.IEnumerator;
using BigInteger = System.Numerics.BigInteger;
using TextReader = System.IO.TextReader;
using StringBuilder = System.Text.StringBuilder;
using static Global;
using static NumGlobal;

static class Global
{
    public static void Swap<T>(ref T a, ref T b) { T tmp = a; a = b; b = tmp; }
    public static T[] NewArray<T>(int len0, T value) => new T[len0].Fill(value);
    public static T[] NewArray<T>(int len0, Func<T> factory)
    {
        var arr = new T[len0];
        for (int i = 0; i < arr.Length; i++) arr[i] = factory();
        return arr;
    }
    public static T[][] NewArray<T>(int len0, int len1, T value) where T : struct
    {
        var arr = new T[len0][];
        for (int i = 0; i < arr.Length; i++) arr[i] = NewArray(len1, value);
        return arr;
    }
    public static T[][] NewArray<T>(int len0, int len1, Func<T> factory)
    {
        var arr = new T[len0][];
        for (int i = 0; i < arr.Length; i++) arr[i] = NewArray(len1, factory);
        return arr;
    }
    public static T[][][] NewArray<T>(int len0, int len1, int len2, T value) where T : struct
    {
        var arr = new T[len0][][];
        for (int i = 0; i < arr.Length; i++) arr[i] = NewArray(len1, len2, value);
        return arr;
    }
    public static T[][][] NewArray<T>(int len0, int len1, int len2, Func<T> factory)
    {
        var arr = new T[len0][][];
        for (int i = 0; i < arr.Length; i++) arr[i] = NewArray(len1, len2, factory);
        return arr;
    }
    public static T[][][][] NewArray<T>(int len0, int len1, int len2, int len3, T value) where T : struct
    {
        var arr = new T[len0][][][];
        for (int i = 0; i < arr.Length; i++) arr[i] = NewArray(len1, len2, len3, value);
        return arr;
    }
    public static T[][][][] NewArray<T>(int len0, int len1, int len2, int len3, Func<T> factory)
    {
        var arr = new T[len0][][][];
        for (int i = 0; i < arr.Length; i++) arr[i] = NewArray(len1, len2, len3, factory);
        return arr;
    }
    private class ComparerReverseImpl<T> : Comparer<T> where T : IComparable<T> { public override int Compare(T y, T x) => x.CompareTo(y); public override bool Equals(object obj) => obj != null && GetType() == obj.GetType(); public override int GetHashCode() => GetType().GetHashCode(); }
    public static IComparer<T> ComparerReverse<T>() where T : IComparable<T> => new ComparerReverseImpl<T>();
    public static string AllLines<T>(IEnumerable<T> source) => string.Join("\n", source);
    public static string AllJoin<T>(IEnumerable<T> source) => string.Join(" ", source);
}
static class NumGlobal
{
    public static int Pow(int x, int y)
    {
        int res = 1;
        for (; y > 0; y >>= 1)
        {
            if ((y & 1) == 1) res *= x;
            x *= x;
        }
        return res;
    }
    public static BigInteger ParseBigInteger(string s)
    {
        // 自前実装の方が速い
        var res = BigInteger.Zero;
        var splited = new string[(s.Length + 7) / 8];
        for (var i = 0; i < splited.Length - 1; i++)
        {
            splited[i] = s.Substring(8 * i, 8);
        }
        splited[splited.Length - 1] = s.Substring(8 * (splited.Length - 1));
        foreach (var sp in splited)
        {
            res *= (int)Math.Pow(10, sp.Length);
            res += int.Parse(sp);
        }
        return res;
    }
    public static int BitCount(int x) { x -= (x >> 1) & 0x55555555; x = (x & 0x33333333) + ((x >> 2) & 0x33333333); x = (x + (x >> 4)) & 0x0f0f0f0f; x += x >> 8; x += x >> 16; return x & 0x3f; }
    public static int BitCount(long x) { x -= (x >> 1) & 0x5555555555555555; x = (x & 0x3333333333333333) + ((x >> 2) & 0x3333333333333333); x = (x + (x >> 4)) & 0x0f0f0f0f0f0f0f0f; x += x >> 8; x += x >> 16; x += x >> 32; return (int)(x & 0x0000007f); }
    public static int MSB(int x) { x |= x >> 1; x |= x >> 2; x |= x >> 4; x |= x >> 8; x |= x >> 16; return BitCount(x) - 1; }
    public static int MSB(long x) { x |= x >> 1; x |= x >> 2; x |= x >> 4; x |= x >> 8; x |= x >> 16; x |= x >> 32; return BitCount(x) - 1; }
    public static int LSB(int x) { x |= x << 1; x |= x << 2; x |= x << 4; x |= x << 8; x |= x << 16; return 32 - BitCount(x); }
    public static int LSB(long x) { x |= x << 1; x |= x << 2; x |= x << 4; x |= x << 8; x |= x << 16; x |= x << 32; return 64 - BitCount(x); }
}
static class Ext
{
    public static T[] Fill<T>(this T[] arr, T value)
    {
        for (var i = 0; i < arr.Length; i++) arr[i] = value;
        return arr;
    }
    public static T[] Sort<T>(this T[] arr) { Array.Sort(arr); return arr; }
    public static string[] Sort(this string[] arr) => Sort(arr, StringComparer.OrdinalIgnoreCase);
    public static T[] Sort<T, U>(this T[] arr, Func<T, U> selector) where U : IComparable<U> => Sort(arr, (a, b) => selector(a).CompareTo(selector(b)));
    public static T[] Sort<T>(this T[] arr, Comparison<T> comparison) { Array.Sort(arr, comparison); return arr; }
    public static T[] Sort<T>(this T[] arr, IComparer<T> comparer) { Array.Sort(arr, comparer); return arr; }
    public static T[] Reverse<T>(this T[] arr) { Array.Reverse(arr); return arr; }
    public static Tuple<int, T> MaxBy<T>(this T[] arr) where T : IComparable<T>
    {
        T max = arr[0];
        int maxIndex = 0;
        for (int i = 0; i < arr.Length; i++)
        {
            if (max.CompareTo(arr[i]) < 0)
            {
                max = arr[i];
                maxIndex = i;
            }
        }
        return Tuple.Create(maxIndex, max);
    }
    public static Tuple<TSource, TMax> MaxBy<TSource, TMax>
        (this IEnumerable<TSource> source, Func<TSource, TMax> maxBySelector)
        where TMax : IComparable<TMax>
    {
        TMax max;
        TSource maxByItem;

        var e = source.GetEnumerator();
        e.MoveNext();
        maxByItem = e.Current;
        max = maxBySelector(maxByItem);
        while (e.MoveNext())
        {
            var item = e.Current;
            var next = maxBySelector(item);
            if (max.CompareTo(next) < 0)
            {
                max = next;
                maxByItem = item;
            }
        }
        return Tuple.Create(maxByItem, max);
    }
    public static Tuple<int, T> MinBy<T>(this T[] arr) where T : IComparable<T>
    {
        T min = arr[0];
        int minIndex = 0;
        for (int i = 0; i < arr.Length; i++)
        {
            if (min.CompareTo(arr[i]) > 0)
            {
                min = arr[i];
                minIndex = i;
            }
        }
        return Tuple.Create(minIndex, min);
    }
    public static Tuple<TSource, TMin> MinBy<TSource, TMin>
        (this IEnumerable<TSource> source, Func<TSource, TMin> minBySelector)
        where TMin : IComparable<TMin>
    {
        TMin min;
        TSource minByItem;

        var e = source.GetEnumerator();
        e.MoveNext();
        minByItem = e.Current;
        min = minBySelector(minByItem);
        while (e.MoveNext())
        {
            var item = e.Current;
            var next = minBySelector(item);
            if (min.CompareTo(next) > 0)
            {
                min = next;
                minByItem = item;
            }
        }
        return Tuple.Create(minByItem, min);
    }
    public static IComparer<T> Reverse<T>(this IComparer<T> comparer) => Comparer<T>.Create((x, y) => comparer.Compare(y, x));
    public static Dictionary<TKey, int> GroupCount<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector) => source.GroupBy(keySelector).ToDictionary(g => g.Key, g => g.Count());
    public static Dictionary<TKey, int> GroupCount<TKey>(this IEnumerable<TKey> source) => source.GroupCount(i => i);
    public static TValue Get<TKey, TValue>(this Dictionary<TKey, TValue> dic, TKey key)
    {
        TValue v;
        dic.TryGetValue(key, out v);
        return v;
    }
    public static TValue GetOrInit<TKey, TValue>(this Dictionary<TKey, TValue> dic, TKey key, TValue value)
    {
        TValue v;
        if (dic.TryGetValue(key, out v))
            return v;
        return dic[key] = value;
    }
}
#pragma warning disable CA1819
[System.Diagnostics.DebuggerNonUserCode]
public class ConsoleReader { private string[] ReadLineSplit() => textReader.ReadLine().Split(Array.Empty<char>(), StringSplitOptions.RemoveEmptyEntries); private string[] line = Array.Empty<string>(); private int linePosition; private TextReader textReader; public ConsoleReader(TextReader tr) { textReader = tr; } public int Int => int.Parse(String); public int Int0 => Int - 1; public long Long => long.Parse(String); public double Double => double.Parse(String); public string String { get { if (linePosition >= line.Length) { linePosition = 0; line = ReadLineSplit(); } return line[linePosition++]; } } public class SplitLine { public SplitLine(ConsoleReader cr) { String = cr.ReadLineSplit(); cr.line = Array.Empty<string>(); } public int[] Int => String.Select(x => int.Parse(x)).ToArray(); public int[] Int0 => String.Select(x => int.Parse(x) - 1).ToArray(); public long[] Long => String.Select(x => long.Parse(x)).ToArray(); public double[] Double => String.Select(x => double.Parse(x)).ToArray(); public string[] String { get; } } public SplitLine Split => new SplitLine(this); public class RepeatReader { ConsoleReader cr; int count; public RepeatReader(ConsoleReader cr, int count) { this.cr = cr; this.count = count; } public T[] Select<T>(Func<ConsoleReader, T> factory) { var arr = new T[count]; for (int i = 0; i < count; i++) arr[i] = factory(cr); return arr; } public string[] String => this.Select(cr => cr.String); public int[] Int => this.Select(cr => cr.Int); public int[] Int0 => this.Select(cr => cr.Int - 1); public long[] Long => this.Select(cr => cr.Long); public double[] Double => this.Select(cr => cr.Double); } public RepeatReader Repeat(int count) => new RepeatReader(this, count); }
public class Program
{
    [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)] private ConsoleReader cr;

    public Program(ConsoleReader consoleReader) { this.cr = consoleReader; }
    static void Main(string[] args) => Console.WriteLine(new Program(new ConsoleReader(args.Length > 0 ? new System.IO.StreamReader(args[0]) : Console.In)).Calc());

    #endregion
    public object Calc()
    {
        var N = cr.Int;
        size = new int[N];
        dp = new Mod[N];
        tree = new GraphBuilder(N, cr, N - 1, false).ToTree(0);
        InitSize(0);
        InitDp(0);

        Mod[] res = new Mod[N];
        res[0] = dp[0];
        var queue = new Queue<int>();
        queue.Enqueue(0);
        while (queue.Count > 0)
        {
            var cur = queue.Dequeue();
            foreach (var child in tree[cur].children)
            {
                var p = res[cur]
                    * factors.FactorialInvers(N - 1)
                    //* factors.Factorial(N - 1 - size[child])
                    * factors.Factorial(size[child])
                    / dp[child]
                    / (N - size[child]);
                res[child] = dp[child] * p * factors.Factorial(N - 1) * factors.FactorialInvers(size[child] - 1);
                queue.Enqueue(child);
            }
        }
        return AllLines(res);
    }
    Mod InitDp(int i)
    {
        if (dp[i].val > 0)
            return dp[i];
        Mod res = factors.Factorial(size[i] - 1);
        foreach (var child in tree[i].children)
            res *= InitDp(child) * factors.FactorialInvers(size[child]);
        return dp[i] = res;
    }
    int InitSize(int i)
    {
        if (size[i] > 0)
            return size[i];

        var res = 1;
        foreach (var child in tree[i].children)
            res += InitSize(child);
        return size[i] = res;
    }
    Mod[] dp;
    Mod.Factor factors = Mod.CreateFactor(1 + (int)1e5);
    int[] size;
    TreeNode[] tree;
}
class GraphBuilder
{
    private List<int>[] roots;
    private List<int>[] children;
    public GraphBuilder(int count, bool isOriented)
    {
        this.roots = new List<int>[count];
        this.children = new List<int>[count];
        for (var i = 0; i < count; i++)
        {
            if (isOriented)
            {
                this.roots[i] = new List<int>();
                this.children[i] = new List<int>();
            }
            else
            {
                this.roots[i] = this.children[i] = new List<int>();
            }
        }
    }
    public GraphBuilder(int count, ConsoleReader cr, int edgeCount, bool isOriented) : this(count, isOriented)
    {
        for (var i = 0; i < edgeCount; i++)
            this.Add(cr.Int0, cr.Int0);
    }
    public void Add(int from, int to)
    {
        children[from].Add(to);
        roots[to].Add(from);
    }
    public TreeNode[] ToTree(int root)
    {
        if (this.roots[0] != this.children[0]) throw new Exception("木には無向グラフをしたほうが良い");
        var res = new TreeNode[this.children.Length];
        res[root] = new TreeNode(root, -1, 0, this.children[root].ToArray());

        var queue = new Queue<int>();
        foreach (var child in res[root].children)
        {
            res[child] = new TreeNode(child, root, 1, Array.Empty<int>());
            queue.Enqueue(child);
        }

        while (queue.Count > 0)
        {
            var from = queue.Dequeue();
            if (res[from].root == -1)
                res[from].children = this.children[from].ToArray();
            else
            {
                var children = new List<int>(this.children[from].Count);
                foreach (var c in this.children[from])
                    if (c != res[from].root)
                        children.Add(c);

                res[from].children = children.ToArray();
            }

            foreach (var child in res[from].children)
            {
                res[child] = new TreeNode(child, from, res[from].depth + 1, Array.Empty<int>());
                queue.Enqueue(child);
            }
        }

        return res;
    }

    public Node[] ToArray() =>
        Enumerable
        .Zip(roots, children, (r, c) => Tuple.Create(r, c))
        .Select((t, i) => new Node(i, t.Item1.ToArray(), t.Item2.ToArray()))
        .ToArray();
}
class TreeNode
{
    public TreeNode(int i, int root, int depth, int[] children)
    {
        this.index = i;
        this.root = root;
        this.children = children;
        this.depth = depth;
    }
    public readonly int index;
    public readonly int root;
    public readonly int depth;
    public int[] children;

    public override string ToString() => $"children: {string.Join(",", children)}";
    public override bool Equals(object obj)
    {
        if (obj is TreeNode)
            return this.Equals((TreeNode)obj);
        else
            return false;
    }
    public bool Equals(TreeNode other) => this.index == other.index;
    public override int GetHashCode() => this.index;
}
class Node
{
    public Node(int i, int[] roots, int[] children)
    {
        this.index = i;
        this.roots = roots;
        this.children = children;
    }
    public readonly int index;
    public readonly int[] roots;
    public readonly int[] children;

    public override string ToString() => $"children: {string.Join(",", children)}";
    public override bool Equals(object obj)
    {
        if (obj is Node)
            return this.Equals((Node)obj);
        else
            return false;
    }
    public bool Equals(Node other) => this.index == other.index;
    public override int GetHashCode() => this.index;
}
struct Mod : IEquatable<Mod>
{
    public const long mod = 1000000007;
    public static readonly Mod invalid = new Mod(-1, false);
    public readonly long val;
    private Mod(long val, bool isValid) : this(val) { if (!isValid) this.val = val; }
    public Mod(long val) { this.val = val % mod; if (this.val < 0) this.val += mod; }
    public override bool Equals(object obj) => (obj is Mod) ? this == ((Mod)obj) : false;
    public bool Equals(Mod obj) => this == obj;
    public override int GetHashCode() => val.GetHashCode();
    public override string ToString() => val.ToString();
    public static implicit operator Mod(long x) => new Mod(x);
    public static Mod operator +(Mod x, Mod y) => (x.val + y.val) % mod;
    public static Mod operator -(Mod x, Mod y) => x.val >= y.val ? (x.val - y.val) % mod : (x.val - y.val) % mod + mod;
    public static Mod operator *(Mod x, Mod y) => (x.val * y.val) % mod;
    public static Mod operator /(Mod x, Mod y) => x * y.Inverse();
    public static bool operator ==(Mod x, Mod y) => x.val == y.val;
    public static bool operator !=(Mod x, Mod y) => x.val != y.val;
    public Mod Inverse()
    {
        long a = val, b = mod, u = 1, v = 0;
        while (b > 0)
        {
            long t = a / b;
            var b2 = a - t * b;
            a = b; b = b2;
            var v2 = u - t * v;
            u = v; v = v2;
        }
        u %= mod;
        if (u < 0) u += mod;
        return u;
    }
    public static Mod Pow(Mod x, int y)
    {
        Mod res = 1;
        for (; y > 0; y >>= 1)
        {
            if ((y & 1) == 1) res *= x;
            x *= x;
        }
        return res;
    }

    public static Factor CreateFactor(int max) => new Factor(max);
    public class Factor
    {
        private readonly Mod[] fac, finv;
        public Factor(int max)
        {
            ++max;
            var inv = new Mod[max];
            fac = new Mod[max]; finv = new Mod[max];
            fac[0] = fac[1] = 1;
            finv[0] = finv[1] = 1;
            inv[1] = 1;
            for (var i = 2; i < max; i++)
            {
                fac[i] = fac[i - 1] * i;
                inv[i] = mod - inv[mod % i].val * (mod / i) % mod;
                finv[i] = finv[i - 1] * inv[i];
            }
        }

        // 二項係数計算
        public Mod Combine(int n, int k)
        {
            if (n < k) return 0;
            if (n < 0 || k < 0) return 0;
            return fac[n] * finv[k] * finv[n - k];
        }

        public Mod Factorial(int n) => fac[n];
        public Mod FactorialInvers(int n) => finv[n];
    }
}