#include "bits/stdc++.h"
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const int INF = 1e9;
const ll LINF = 1e18;
inline ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
inline ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
template <class S, class T>
ostream& operator<<(ostream& out, const pair<S, T>& o) {
    out << "(" << o.first << "," << o.second << ")";
    return out;
}
template <class T>
ostream& operator<<(ostream& out, const vector<T>& V) {
    for (int i = 0; i < V.size(); i++) {
        out << V[i];
        if (i != V.size() - 1) out << " ";
    }
    return out;
}
template <class T>
ostream& operator<<(ostream& out, const vector<vector<T>>& Mat) {
    for (int i = 0; i < Mat.size(); i++) {
        if (i != 0) out << endl;
        out << Mat[i];
    }
    return out;
}
template <class S, class T>
ostream& operator<<(ostream& out, const map<S, T>& mp) {
    out << "{ ";
    for (auto it = mp.begin(); it != mp.end(); it++) {
        out << it->first << ":" << it->second;
        if (mp.size() - 1 != distance(mp.begin(), it)) out << ", ";
    }
    out << " }";
    return out;
}
template <typename T>
vector<T> make_v(size_t a) {
    return vector<T>(a);
}
template <typename T, typename... Ts>
auto make_v(size_t a, Ts... ts) {
    return vector<decltype(make_v<T>(ts...))>(a, make_v<T>(ts...));
}
template <typename T, typename V>
typename enable_if<is_class<T>::value == 0>::type fill_v(T& t, const V& v) {
    t = v;
}
template <typename T, typename V>
typename enable_if<is_class<T>::value != 0>::type fill_v(T& t, const V& v) {
    for (auto& e : t) fill_v(e, v);
}
/*
 <url:>
 問題文============================================================
 =================================================================
 解説=============================================================
 ================================================================
 */

const ll MAX_N = 3e6 + 10;
const ll MOD = 1e9 + 7;
ll Inv[MAX_N];
ll fact[MAX_N];
ll factInv[MAX_N];
void Inv_init() {
    Inv[1] = 1;
    for (int i = 2; i < MAX_N; i++) {
        Inv[i] = Inv[MOD % i] * (MOD - MOD / i) % MOD;
    }
}
void fact_init() {
    fact[0] = fact[1] = factInv[0] = factInv[1] = 1;
    for (int i = 2; i < MAX_N; i++) {
        fact[i] = (fact[i - 1] * i) % MOD;
        factInv[i] = (factInv[i - 1] * Inv[i]) % MOD;
    }
}

// a^b % MOD;
ll powmod(ll a, ll b) {
    ll res = 1;
    a %= MOD;
    for (; b; b >>= 1) {
        if (b & 1) res = res * a % MOD;
        a = a * a % MOD;
    }
    return res;
}
// 逆元 1/a % MOD
ll inversemod(ll a) { return powmod(a, MOD - 2); }

void init() {
    Inv_init();
    fact_init();
}

template <class Type>
Type solve(Type res = Type()) {
    init();

    int N;
    cin >> N;
    vector<vector<int>> G(N);
    for (int i = 0; i < N - 1; i++) {
        int a, b;
        cin >> a >> b;
        a--;
        b--;
        G[a].emplace_back(b);
        G[b].emplace_back(a);
    }

    auto dp1 = make_v<ll>(N);
    auto SZ = make_v<ll>(N);

    function<void(int, int)> dfs1 = [&](int n, int par) {
        int ChSZ = 0;

        dp1[n] = 1;

        for (const int& next : G[n]) {
            if (next == par) continue;
            dfs1(next, n);
            dp1[n] = dp1[n] * factInv[SZ[next]] % MOD * dp1[next] % MOD;
            ChSZ += SZ[next];
        }
        dp1[n] = dp1[n] * fact[ChSZ] % MOD;
        SZ[n] = ChSZ + 1;
    };
    dfs1(0, -1);

    // cout << dp1 << endl;

    auto dp2 = make_v<ll>(N);
    dp2[0] = dp1[0];
    function<void(int, int, ll, ll)> dfs2 = [&](int n, int par, ll par_val,
                                                ll par_sz) {
        if (n != 0) {
            dp2[n] = par_val * factInv[par_sz] % MOD;

            for (const int& next : G[n]) {
                if (next == par) continue;

                dp2[n] = dp2[n] * dp1[next] % MOD;
                dp2[n] = dp2[n] * factInv[SZ[next]] % MOD;
            }

            dp2[n] = dp2[n] * fact[N - 1] % MOD;
        }

        for (const int& next : G[n]) {
            if (next == par) continue;

            ll val = dp2[n];
            ll sz = N - SZ[next];

            val = val * fact[SZ[next]]%MOD * inversemod(dp1[next]) % MOD;
            val = val * factInv[N-1] %MOD * fact[sz-1] % MOD;

            dfs2(next,n,val,sz);
        }
    };
    dfs2(0, -1, -1, -1);
    for(auto ans:dp2){
        cout << ans << endl;
    }
    return res;
}
int main(void) {
    cin.tie(0);
    ios::sync_with_stdio(false);
    solve<ll>(0);
    // cout << fixed << setprecision(12) << solve<ll>() << endl;
    return 0;
}

Measured memory_bytes: 89748