#include <bits/stdc++.h>
using namespace std;
#define SELECTER(_1, _2, _3, SELECT, ...) SELECT
#define REP1(i, n) for(int i=0; (i)<(n); (i)++)
#define REP2(i, a, b) for(int i=(a); (i)<(b); (i)++)
#define REP(...) SELECTER(__VA_ARGS__, REP2, REP1,) (__VA_ARGS__)
#define MOD 1000000007

template <class T> ostream& operator<<(ostream& os, const vector<T>& v){ os << "{"; for(size_t i=0; i<v.size(); i++) os << v[i] << (i+1==v.size() ? "" : ", "); os << "}"; return os; }
template <class T, class U> ostream& operator<<(ostream& os, const pair<T, U>& p){ return os << "{" << p.first << ", " << p.second << "}"; }

class Comb{
    // テーブルを作るのに O(NlogN)
    // 計算は O(1)
    int N;
    vector<long long> fact_num, fact_den;
    long long bipow(long long n, long long m) {
        if (m == 0) return 1;
        if (m % 2 == 0) {
            n = (n * n) % MOD;
            return bipow(n, m / 2) % MOD;
        } else
            return (n * bipow(n, m - 1)) % MOD;
    }
    void set_table(){
        fact_num.resize(N+1, 0);
        fact_den.resize(N+1, 0);
        vector<long long> fact_denpow(N+1, 0);

        fact_num[0] = 1;
        for(int i=1; i<=N; i++) fact_num[i] = (fact_num[i-1] * i) % MOD;
        for(int i=0; i<=N; i++) fact_denpow[i] = bipow(i, MOD-2);
        fact_den[0] = 1;
        for(int i=1; i<=N; i++) fact_den[i] = (fact_den[i-1] * fact_denpow[i]) % MOD;
    }
public:
    Comb(int N): N(N) { set_table(); }
    // nCk
    long long calc(long long n, long long k){
        if(k > n) return 0;
        return ((fact_num[n] * fact_den[k]) % MOD * fact_den[n-k]) % MOD;
    }
} comb(202020);

struct Rerooting{
    struct DP{
        long long dp;
        long long t;
        DP() : dp(1), t(0) {}
        DP operator+(const DP &a) const{
            DP b(*this);
            b.dp *= a.dp;
            b.dp %= MOD;
            b.dp *= comb.calc(a.t+b.t, a.t);
            b.dp %= MOD;
            b.t += a.t;
            b.t %= MOD;
            return b;
        }
        DP addRoot() const{
            DP b(*this);
            b.t++;
            return b;
        }
    };

    int n;
    vector<vector<int>> to; // グラフ隣接リスト
    vector<vector<DP>> dp;  // dp[v][i]: ノードvからi番目の頂点への辺に対する値
    vector<DP> ans;         // ans[v]: ノードvを根としたときの値
    Rerooting(int n) : n(n), to(n), dp(n), ans(n) {}
    void addEdge(int a, int b){
        to[a].push_back(b);
        to[b].push_back(a);
    }
    void init(){
        dfs(0);
        bfs(0);
    }
    DP dfs(int v, int p=-1){
        // 頂点vを根としたとき、各dpを再帰的に計算する
        DP dpSum;
        dp[v] = vector<DP>(to[v].size());
        for(size_t i=0; i<to[v].size(); i++){
            int u = to[v][i];
            if(u == p) continue;
            dp[v][i] = dfs(u, v);
            dpSum = dpSum + dp[v][i];
        }
        return dpSum.addRoot();
    }
    void bfs(int v, const DP &dpP=DP(), int p=-1){
        // dpP: vから親へ向かう辺に対応する値
        // ansを再帰的に計算する
        int deg = to[v].size();
        for(int i=0; i<deg; i++)
            if(to[v][i] == p) dp[v][i] = dpP;
        vector<DP> dpSumL(deg+1), dpSumR(deg+1);
        for(int i=0; i<deg; i++)
            dpSumL[i+1] = dpSumL[i] + dp[v][i];
        for(int i=deg-1; i>=0; i--)
            dpSumR[i] = dpSumR[i+1] + dp[v][i];
        ans[v] = dpSumL[deg].addRoot();
        for(int i=0; i<deg; i++){
            int u = to[v][i];
            if (u == p) continue;
            bfs(u, (dpSumL[i] + dpSumR[i+1]).addRoot(), v);
        }
    }
};

int main(){
    int N;
    cin >> N;
    Rerooting rr(N);
    REP(i, N-1){
        int a, b;
        cin >> a >> b;
        a--; b--;
        rr.addEdge(a, b);
    }
    rr.init();
    for(int i=0; i<N; i++)
        cout << rr.ans[i].dp << endl;

    return 0;
}

Measured memory_bytes: 38612