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 Rust (1.15.1) (judge verdict: Accepted)

#[macro_use]
mod input_mcr {
    // ref: tanakh <https://qiita.com/tanakh/items/0ba42c7ca36cd29d0ac8>
    // diff: using Parser
    #[macro_export(local_inner_macros)]
    macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut parser = Parser::from_str($s);
        input_inner!{parser, $($r)*}
    };
    (parser = $parser:ident, $($r:tt)*) => {
        input_inner!{$parser, $($r)*}
    };
    (new_stdin_parser = $parser:ident, $($r:tt)*) => {
        let stdin = std::io::stdin();
        let reader = std::io::BufReader::new(stdin.lock());
        let mut $parser = Parser::new(reader);
        input_inner!{$parser, $($r)*}
    };
    ($($r:tt)*) => {
        input!{new_stdin_parser = parser, $($r)*}
    };
}

    #[macro_export(local_inner_macros)]
    macro_rules! input_inner {
    ($parser:ident) => {};
    ($parser:ident, ) => {};
    ($parser:ident, $var:ident : $t:tt $($r:tt)*) => {
        let $var = read_value!($parser, $t);
        input_inner!{$parser $($r)*}
    };
}

    #[macro_export(local_inner_macros)]
    macro_rules! read_value {
    ($parser:ident, ( $($t:tt),* )) => {
        ( $(read_value!($parser, $t)),* )
    };
    ($parser:ident, [ $t:tt ; $len:expr ]) => {
        (0..$len).map(|_| read_value!($parser, $t)).collect::<Vec<_>>()
    };
    ($parser:ident, chars) => {
        read_value!($parser, String).chars().collect::<Vec<char>>()
    };
    ($parser:ident, char_) => {
        read_value!($parser, String).chars().collect::<Vec<char>>()[0]
    };
    ($parser:ident, usize1) => {
        read_value!($parser, usize) - 1
    };
    ($parser:ident, line) => {
        $parser.next_line()
    };
    ($parser:ident, line_) => {
        $parser.next_line().chars().collect::<Vec<char>>()
    };
    ($parser:ident, i64_) => {
        $parser.fast_i64()
    };
    ($parser:ident, usize_) => {
        $parser.fast_i64() as usize
    };
    ($parser:ident, usize1_) => {
        ($parser.fast_i64() - 1) as usize
    };
    ($parser:ident, $t:ty) => {
        $parser.next::<$t>().expect("Parse error")
    };
}

    use std::io;
    use std::io::BufRead;
    use std::str;

    // ref: tatsuya6502 <https://qiita.com/tatsuya6502/items/cd448486f7ef7b5b8c7e>
    // ref: wariuni <https://qiita.com/tatsuya6502/items/cd448486f7ef7b5b8c7e#comment-7040a5ae96305e884eb9>
    // diff: using std::io::BufRead::fill_buf()
    pub struct Parser<R> {
        pub reader: R,
        buf: Vec<u8>,
        pos: usize,
    }

    impl Parser<io::Empty> {
        pub fn from_str(s: &str) -> Parser<io::Empty> {
            Parser {
                reader: io::empty(),
                buf: s.as_bytes().to_vec(),
                pos: 0,
            }
        }
    }

    impl<R: BufRead> Parser<R> {
        pub fn new(reader: R) -> Parser<R> {
            Parser {
                reader: reader,
                buf: vec![],
                pos: 0,
            }
        }
        pub fn update_buf(&mut self) {
            self.buf.clear();
            self.pos = 0;
            loop {
                let (len, complete) = {
                    let buf2 = self.reader.fill_buf().unwrap();
                    self.buf.extend_from_slice(buf2);
                    let len = buf2.len();
                    (len, buf2[len - 1] <= 0x20)
                };
                self.reader.consume(len);
                if complete {
                    break;
                }
            }
        }
        pub fn next<T: str::FromStr>(&mut self) -> Result<T, T::Err> {
            loop {
                let mut begin = self.pos;
                while begin < self.buf.len() && (self.buf[begin] <= 0x20) {
                    begin += 1;
                }
                let mut end = begin;
                while end < self.buf.len() && (self.buf[end] > 0x20) {
                    end += 1;
                }
                if begin != self.buf.len() {
                    self.pos = end;
                    return unsafe { str::from_utf8_unchecked(&self.buf[begin..end]) }.parse::<T>();
                } else {
                    self.update_buf();
                }
            }
        }
        pub fn next_line(&mut self) -> String {
            loop {
                let mut begin = self.pos;
                if begin < self.buf.len() && (self.buf[begin] < 0x20) {
                    begin += 1;
                }
                let mut end = begin;
                while end < self.buf.len() && (self.buf[end] >= 0x20) {
                    end += 1;
                }
                if begin != self.buf.len() {
                    self.pos = end;
                    return unsafe { str::from_utf8_unchecked(&self.buf[begin..end]) }.to_string();
                } else {
                    self.update_buf();
                }
            }
        }
        pub fn fast_i64(&mut self) -> i64 {
            loop {
                let mut begin = self.pos;
                while begin < self.buf.len() && (self.buf[begin] <= 0x20) {
                    begin += 1;
                }
                if begin == self.buf.len() {
                    self.update_buf();
                    continue;
                }
                let mut res = 0;
                let (is_positive, mut end) = match self.buf[begin] {
                    b'+' => (true, begin + 1),
                    b'-' => (false, begin + 1),
                    _ => (true, begin),
                };
                while end < self.buf.len() && (self.buf[end] > 0x20) {
                    res = res * 10 + (self.buf[end] as i64 - '0' as i64);
                    end += 1;
                }
                if begin != self.buf.len() {
                    self.pos = end;
                    return if is_positive { res } else { -res };
                } else {
                    self.update_buf();
                }
            }
        }
    }
}

mod modular {
    use std::marker::PhantomData;
    use std::ops::*;

    pub trait ModP {
        fn as_u64() -> u64;
    }

    #[allow(non_camel_case_types)]
    #[derive(Clone, Copy, Debug)]
    pub struct Mod_1_000_000_007();
    impl ModP for Mod_1_000_000_007 {
        fn as_u64() -> u64 {
            1_000_000_007
        }
    }

    #[allow(non_camel_case_types)]
    #[derive(Clone, Copy, Debug)]
    pub struct Mod_998_244_353();
    impl ModP for Mod_998_244_353 {
        fn as_u64() -> u64 {
            998_244_353
        }
    }

    #[derive(Clone, Copy, PartialEq, Debug)]
    pub struct Modular<P: ModP + Copy>(u32, PhantomData<P>);

    impl<P: ModP + Copy> Modular<P> {
        pub fn new(x: u32) -> Modular<P> {
            Modular((x as u64 % P::as_u64()) as u32, PhantomData)
        }
        pub fn pow(self, n: u64) -> Modular<P> {
            if n == 0 {
                return Modular(1, PhantomData);
            }
            let t = self.pow(n / 2);
            if n % 2 == 0 {
                t * t
            } else {
                t * t * self
            }
        }
        pub fn as_u32(self) -> u32 {
            self.0
        }
    }

    impl<P: ModP + Copy> Add for Modular<P> {
        type Output = Self;
        fn add(self, rhs: Self) -> Self::Output {
            let t = (self.0 + rhs.0) as u64;
            let u = if t < P::as_u64() { t } else { t - P::as_u64() };
            Modular(u as u32, PhantomData)
        }
    }

    impl<P: ModP + Copy> AddAssign for Modular<P> {
        fn add_assign(&mut self, rhs: Self) {
            *self = *self + rhs;
        }
    }

    impl<P: ModP + Copy> Sub for Modular<P> {
        type Output = Self;
        fn sub(self, rhs: Self) -> Self::Output {
            let t = if self.0 >= rhs.0 {
                self.0 as u64 - rhs.0 as u64
            } else {
                self.0 as u64 + P::as_u64() - rhs.0 as u64
            };
            assert!(t < P::as_u64());
            Modular(t as u32, PhantomData)
        }
    }

    impl<P: ModP + Copy> SubAssign for Modular<P> {
        fn sub_assign(&mut self, rhs: Self) {
            *self = *self - rhs;
        }
    }

    impl<P: ModP + Copy> Neg for Modular<P> {
        type Output = Modular<P>;
        fn neg(self) -> Modular<P> {
            Modular((P::as_u64() - self.0 as u64) as u32, PhantomData)
        }
    }

    impl<P: ModP + Copy> Mul for Modular<P> {
        type Output = Self;
        fn mul(self, rhs: Self) -> Self::Output {
            Modular(
                ((self.0 as u64 % P::as_u64()) * (rhs.0 as u64 % P::as_u64()) % P::as_u64()) as u32,
                PhantomData,
            )
        }
    }

    impl<P: ModP + Copy> MulAssign for Modular<P> {
        fn mul_assign(&mut self, rhs: Self) {
            *self = *self * rhs;
        }
    }

    impl<P: ModP + Copy> Div for Modular<P> {
        type Output = Self;
        fn div(self, rhs: Self) -> Self::Output {
            if rhs.0 == 0 {
                loop {}
            }
            assert!(rhs.0 != 0);
            self * rhs.pow(P::as_u64() - 2)
        }
    }

    impl<P: ModP + Copy> DivAssign for Modular<P> {
        fn div_assign(&mut self, rhs: Self) {
            *self = *self / rhs;
        }
    }

    pub fn gen_fact_table<P: ModP + Copy>(n: usize) -> Vec<Modular<P>> {
        let mut res = vec![Modular::<P>::new(1); n + 1];
        for i in 0..n {
            res[i + 1] = res[i] * Modular::<P>::new((i + 1) as u32);
        }
        res
    }

    pub fn gen_inv_table<P: ModP + Copy>(n: usize) -> Vec<Modular<P>> {
        let mut res = vec![Modular::<P>::new(0); n + 1];
        res[1] = Modular::<P>::new(1);
        for i in 2..n + 1 {
            res[i] =
                -res[P::as_u64() as usize % i] * Modular::<P>::new((P::as_u64() / i as u64) as u32);
        }
        res
    }

    /*
    #[test]
    fn test_modular_1_000_000_007() {
        type Mod = Modular<Mod_1_000_000_007>;
        assert_eq!(Mod::new(2).pow(1_000_000).as_u32(), 235_042_059)
    }

    #[test]
    fn test_modular_998_244_353() {
        type Mod = Modular<Mod_998_244_353>;
        assert_eq!(Mod::new(2).pow(1_000_000).as_u32(), 421_273_117);
    }
    */
}

mod combination {
    use modular::*;

    pub struct Combination<T> {
        facts: Vec<T>,
        inv_facts: Vec<T>,
    }

    use std::fmt::Debug;
    impl<P: ModP + Copy + Debug> Combination<Modular<P>> {
        pub fn new(n: usize) -> Combination<Modular<P>> {
            let mut facts = vec![Modular::<P>::new(1)];
            for i in 1..n {
                let t = facts[i - 1];
                facts.push(t * Modular::<P>::new(i as u32));
            }
            let mut inv_facts = vec![];
            inv_facts.push(Modular::<P>::new(1) / facts[n - 1]);
            for i in (1..n - 1).rev() {
                let t = *inv_facts.last().unwrap();
                inv_facts.push(t * Modular::<P>::new((i + 1) as u32));
            }
            inv_facts.push(Modular::<P>::new(1));
            inv_facts.reverse();
            Combination {
                facts: facts,
                inv_facts: inv_facts,
            }
        }
        pub fn c(&self, n: usize, r: usize) -> Modular<P> {
            if n < r {
                Modular::<P>::new(0)
            } else {
                self.facts[n] * self.inv_facts[n - r] * self.inv_facts[r]
            }
        }
    }
}

use input_mcr::*;
use std::cmp::*;

use modular::*;
type Mod = Modular<Mod_1_000_000_007>;

use combination::*;

fn merge(x: (usize, Mod), y: (usize, Mod), comb: &Combination<Mod>) -> (usize, Mod) {
    (x.0 + y.0, comb.c(x.0 + y.0, x.0) * x.1 * y.1)
}

fn dfs1(
    graph: &Vec<Vec<usize>>,
    i: usize,
    prev: Option<usize>,
    merges: &mut Vec<(Vec<(usize, Mod)>, Vec<(usize, Mod)>)>,
    comb: &Combination<Mod>,
) -> (usize, Mod) {
    let mut xs = vec![];
    for &next in &graph[i] {
        if Some(next) == prev {
            xs.push((0, Mod::new(1)));
            continue;
        }
        let t = dfs1(graph, next, Some(i), merges, comb);
        xs.push(t);
    }
    if !xs.is_empty() {
        merges[i].0.push((0, Mod::new(1)));
        for k in 0..xs.len() {
            let t = *merges[i].0.last().unwrap();
            merges[i].0.push(merge(t, xs[k], comb));
        }
        merges[i].1.push((0, Mod::new(1)));
        for k in (0..xs.len()).rev() {
            let t = *merges[i].1.last().unwrap();
            merges[i].1.push(merge(xs[k], t, comb));
        }
        merges[i].1.reverse();
    }
    (merges[i].1[0].0 + 1, merges[i].1[0].1)
}

fn dfs2(
    graph: &Vec<Vec<usize>>,
    i: usize,
    prev: Option<usize>,
    merges: &Vec<(Vec<(usize, Mod)>, Vec<(usize, Mod)>)>,
    comb: &Combination<Mod>,
    res: &mut Vec<Mod>,
    pres: (usize, Mod),
) {
    // eprintln!("i = {}, pres = {:?}", i, pres);
    res[i] = merge(pres, merges[i].1[0], comb).1;
    for (k, &next) in graph[i].iter().enumerate() {
        if Some(next) == prev {
            continue;
        }
        let t = merge(pres, merges[i].0[k], comb);
        let t = merge(t, merges[i].1[k + 1], comb);
        let t = (t.0 + 1, t.1);
        dfs2(graph, next, Some(i), merges, comb, res, t);
    }
}

fn main() {
    input! {
        n: usize,
        es: [(usize1,usize1); n-1],
    }
    let mut graph = vec![vec![]; n];
    for &(s, t) in &es {
        graph[s].push(t);
        graph[t].push(s);
    }
    let comb = Combination::new(5_00000);
    let mut merges = vec![(vec![], vec![]); n];
    let mut res = vec![Mod::new(0); n];
    dfs1(&graph, 0, None, &mut merges, &comb);
    for i in 0..n {
        // eprintln!("merges[{}].0 = {:?}", i, merges[i].0);
        // eprintln!("merges[{}].1 = {:?}", i, merges[i].1);
    }
    dfs2(&graph, 0, None, &merges, &comb, &mut res, (0, Mod::new(1)));
    for &r in &res {
        println!("{}", r.as_u32());
    }
}