#include <bits/stdc++.h>
using namespace std;
using LL = long long;
using vvi = vector<vector<int>>;
using P = pair<int, int>;
#define repex(i, a, b, c) for(int i = a; i < b; i += c)
#define repx(i, a, b) repex(i, a, b, 1)
#define rep(i, n) repx(i, 0, n)
#define repr(i, a, b) for(int i = a; i >= b; i--)
#define pb push_back
#define a first
#define b second
const LL MOD = 1e9 + 7;
const int LIMIT = 202020;
LL FAC[LIMIT], INV[LIMIT];
int d[LIMIT];    // 頂点 1 からの 距離 を 保存.
int size[LIMIT]; // 木の大きさ.
LL dp[LIMIT];    // 木dp.

// グラフを幅優先探索する.
// https://ja.wikipedia.org/wiki/幅優先探索
// ※bfsの動作確認用.
// @param G: グラフ.
// @param s: グラフの探索開始頂点.
// @param d: 探索開始地点からの距離.
// @return: 特に無し.
void bfs(vvi &G, int s, int* d){
    // 1. 空のキュー.
    queue<int> q;
    
    // 2. 訪問済みフラグ設定.
    // ※スタート地点は, 距離ゼロを指定.
    d[s] = 0;
    
    // 3. 探索地点 s をキュー q に追加.
    q.push(s);
    while(!q.empty()){
        // 4. キューから取り出す.
        int u = q.front();
        q.pop();
        
        // 5. 取り出した要素を処理.
        for(auto &e : G[u]){
            // 6. 訪問済であれば, 処理をスキップ.
            if(d[e] > 0)            continue;
            if(d[e] == 0 && e != s) d[e] = d[u] + 1, q.push(e);
        }
    }
    return;
}

// Fermat's little theorem から, 大きな冪乗の計算を行う.
// @param a: べき乗したい正整数.
// @param b: 指数.
// @return:  べき乗した計算結果(mod版).
LL mPow(LL a, LL b){
    LL t = 1;
    while(b){
        if(b & 1) t = (t * a) % MOD;
        a = a * a % MOD;
        b >>= 1;
    }
    return t % MOD;
}

int main(){
    
    // 1. 入力情報.
    int N, a, b;
    scanf("%d", &N);
    vvi G(N);
    rep(i, N - 1){
        scanf("%d %d", &a, &b);
        a--, b--;
        G[a].pb(b);
        G[b].pb(a);
    }
    
    // ※ 以下, 解説通り.
    // 2. 事前計算.
    FAC[0] = 1;
    repx(i, 1, LIMIT) FAC[i] = (LL)i * FAC[i - 1] % MOD;
    rep(i, LIMIT)     INV[i] = mPow(FAC[i], MOD - 2);
    rep(i, LIMIT)     size[i] = 1, dp[i] = 1;
    
    // 3. 頂点 1 から 各頂点までの距離を計算.
    bfs(G, 0, d);
    
    // 4. 頂点 1 から 遠い順, 近い順 に並び替え.
    priority_queue<P> fPq;
    priority_queue<P, vector<P>, greater<P>> nPq;
    rep(i, N){
        // {距離, 頂点番号}
        fPq.push({d[i], i});
        nPq.push({d[i], i});
    }
    
    // 5. 木dp.
    while(!fPq.empty()){
        // 5-1. 頂点 v を一つ取り出す.
        P p = fPq.top();
        fPq.pop();
        // printf("%d %d\n", p.a, p.b);
        
        // 5-2. 頂点 v の 頂点番号は？
        int v = p.b;
        
        // 5-3. 頂点 v を 根とする部分木 の サイズ を 集計しながら, 木dp も 更新.
        for(auto &u : G[v]){
            // 頂点 v の 子供 に 相当する頂点 u を 選択.
            if(d[u] > d[v]){
                // 頂点 v の 周囲 の 頂点 u で, 頂点 1 から, より遠いものを加算.
                size[v] += size[u];
                // 頂点 v の 周囲 の 頂点 u について, 木dp の 更新.
                dp[v] *= dp[u];
                dp[v] %= MOD;
                dp[v] *= INV[size[u]];
                dp[v] %= MOD;
            }
        }
        
        // 5-4. 頂点 v を 根とする部分木 の サイズ を 考慮し, 木dp を 更新.
        dp[v] *= FAC[size[v] - 1];
        dp[v] %= MOD;
    }
    
    // 6. 全方位木dp.
    while(!nPq.empty()){
        // 6-1. 頂点 u を一つ取り出す.
        P p = nPq.top();
        nPq.pop();
        // printf("%d %d\n", p.a, p.b);
        
        // 6-2. 頂点 u の 頂点番号は？
        int u = p.b;
        
        // 6-3. 頂点 u の 周囲の頂点 を見ながら, 自身(u) を 集計.
        LL dpu = dp[u];
        LL calc = 1;
        // printf("start dp[%d]=%lld\n", u, dpu);
        for(auto &v : G[u]){
            // もともと, 頂点 v が 頂点 u の 親頂点 である場合.
            if(d[u] > d[v]){
                // 頂点 v の dp[v] を 再計算.
                dpu *= dp[v];
                dpu %= MOD;
                
                // 頂点 u の 分 を 割り戻す.
                dpu *= mPow(dp[u], MOD - 2);
                dpu %= MOD;
                dpu *= FAC[size[u]];
                dpu %= MOD;
                
                // 頂点 u の 子頂点 を 考慮.
                dpu *= INV[size[u] - 1];
                dpu %= MOD;
                
                // 頂点 v が 子頂点 の 立場 になったので, 再計算.
                dpu *= INV[N - 1];
                dpu %= MOD;
                dpu *= FAC[N - 1 - size[u]];
                dpu %= MOD;
                
                // 頂点 u が 親になるので, 頂点 v が 子頂点 とした場合について 逆元 を 乗ずる.
                dpu *= FAC[N - 1];
                dpu %= MOD;
                dpu *= INV[N - size[u]];
                dpu %= MOD;
                calc = dp[v] * mPow(dp[u], MOD - 2) % MOD * FAC[size[u]] % MOD * INV[N - 1] % MOD * FAC[N - 1 - size[u]] % MOD * FAC[N - 1] % MOD * INV[N - size[u]] % MOD;
                // printf("--- calc=%lld\n", calc);
                // printf("--- dpu=%lld dp[%d]=%lld size[u]=%d size[v]=%d\n", dpu, v, dp[v], size[u], size[v]);
            }
        }
        
        // 6-4. 木dp の 更新.
        dp[u] = dpu;
    }
    
    // 7. 出力.
    rep(i, N) printf("%lld\n", dp[i]);
    return 0;
    
}

Measured memory_bytes: 23448