#include "bits/stdc++.h"
using namespace std;
typedef long long ll;

template<long long mod>
struct mint {
private:
    long long x;
public:
    mint(long long x = 0) :x((mod + x) % mod) {}
    mint(std::string &s) {
        long long z = 0;
        for (int i = 0; i < s.size(); i++) {
            z *= 10;
            z += s[i] - '0';
            z %= mod;
        }
        this->x = z;
    }
    mint& operator+=(const mint &a) {
        if ((x += a.x) >= mod) x -= mod;
        return *this;
    }
    mint& operator-=(const mint &a) {
        if ((x += mod - a.x) >= mod) x -= mod;
        return *this;
    }
    mint& operator*=(const mint &a) {
        (x *= a.x) %= mod;
        return *this;
    }
    mint& operator/=(const mint &a) {
        long long n = mod - 2;
        mint<mod> u = 1, b = a;
        while (n > 0) {
            if (n & 1) {
                u *= b;
            }
            b *= b;
            n >>= 1;
        }
        return *this *= u;
    }
    mint operator+(const mint &a) const {
        mint res(*this);
        return res += a;
    }
    mint operator-(const mint &a) const {
        mint res(*this);
        return res -= a;
    }
    mint operator*(const mint &a) const {
        mint res(*this);
        return res *= a;
    }
    mint operator/(const mint &a) const {
        mint res(*this);
        return res /= a;
    }
    friend std::ostream& operator<<(std::ostream &os, const mint &n) {
        return os << n.x;
    }
    bool operator==(const mint &a) const {
        return this->x == a.x;
    }
};

constexpr int MOD = 1e9 + 7;

using T = mint<MOD>; // データ型
int n; // 頂点
vector<vector<int>> tree;
vector<int> sz; // 根付き木中の i の
vector<T> dp; // 根付き木中の i の
vector<T> ans;

// comb (前計算O(NlogMOD) クエリO(1))
vector<mint<MOD>> FACT, IFACT;

// 部分木のサイズ
void dfs1(int v, int p = -1) {
    int res = 1;
    for (auto &u : tree[v]) {
        if (u == p) continue;
        dfs1(u, v);
        res += sz[u];
    }
    sz[v] = res;
    dp[v] = FACT[sz[v] - 1];
    for (int u : tree[v]) {
        if (u == p) continue;
        dp[v] *= dp[u] * IFACT[sz[u]];
    }
    //cout << v << " " << dp[v] << " " << sz[v] << endl;
}

void dfs2(int v, T d_par, int p = -1) {
    // v における答えの計算
    ans[v] = dp[v] * IFACT[sz[v] - 1] * d_par * IFACT[n - sz[v]] * FACT[n - 1];

    // 左右からの累積演算を用いて子に送る d_par の計算
    // lf[i] : [:i-1]の演算結果
    // ri[i] : [i+1:]の演算結果
    auto f = [](T a, T b) { return a * b; }; // 演算
    int e = 1; // 演算の単位元
    vector<T> lf(tree[v].size(), e), ri(tree[v].size(), e); // 累積配列
    for (int i = 1; i < tree[v].size(); i++) {
        if (tree[v][i - 1] == p) lf[i] = f(d_par * IFACT[n - sz[v]], lf[i - 1]);
        else lf[i] = f(dp[tree[v][i - 1]] * IFACT[sz[tree[v][i - 1]]], lf[i - 1]);
    }
    for (int i = tree[v].size() - 2; i >= 0; i--) {
        if (tree[v][i + 1] == p) ri[i] = f(d_par * IFACT[n - sz[v]], ri[i + 1]);
        else ri[i] = f(dp[tree[v][i + 1]] * IFACT[sz[tree[v][i + 1]]], ri[i + 1]);
    }
    for (int i = 0; i < tree[v].size(); i++) {
        if (tree[v][i] == p) continue;
        dfs2(tree[v][i], f(lf[i], ri[i]) * FACT[n - sz[tree[v][i]] - 1], v);
    }
}

int main() {
    cin >> n;
    tree.resize(n);
    sz.resize(n);
    ans.resize(n);
    dp.resize(n);
    int MAX_N = n;
    FACT.resize(MAX_N + 1);
    IFACT.resize(MAX_N + 1);
    FACT[0] = 1;
    IFACT[0] = 1;
    for (int i = 1; i <= MAX_N; i++) {
        FACT[i] = FACT[i - 1] * i;
        IFACT[i] = mint<MOD>(1) / FACT[i];
    }
    for (int i = 0; i < n - 1; i++) {
        int u, v; cin >> u >> v;
        u--; v--;
        tree[u].push_back(v);
        tree[v].push_back(u);
    }
    dfs1(0);
    dfs2(0, 1);
    for (int i = 0; i < n; i++) {
        cout << ans[i] << endl;
    }
    return 0;
}

Measured memory_bytes: 22132