#include <bits/stdc++.h>
using namespace std;

using int32 = int_fast32_t;
using int64 = int_fast64_t;

const int32 INF = 1e9;
const int32 MOD = 1e9+7;
const int64 LLINF = 1e18;

#define YES(n) cout << ((n) ? "YES\n" : "NO\n"  )
#define Yes(n) cout << ((n) ? "Yes\n" : "No\n"  )
#define ANS(n) cout << (n) << "\n"
#define REP(i,n) for(int64 i=0;i<(n);++i)
#define FOR(i,a,b) for(int64 i=(a);i<(b);i++)
#define FORR(i,a,b) for(int64 i=(a);i>=(b);i--)
#define ALL(obj) (obj).begin(),(obj).end()
#define pii pair<int32,int32>
#define pll pair<int64,int64>
#define pb(a) push_back(a)
#define mp make_pair

template<int64 mod>
struct ModInt{
    int64 x;
    constexpr ModInt(int64 y = 0):x((y%mod+mod)%mod){}
    constexpr ModInt& operator+=(const ModInt& a){
        if((x += a.x) >= mod) x -= mod;
        return *this;
    }
    constexpr ModInt& operator-=(const ModInt& a){
        if((x -= a.x) < 0)x += mod;
        return *this;
    }
    constexpr ModInt& operator*=(const ModInt& a){
        x = x * a.x % mod;
        return *this;
    }
    constexpr ModInt& operator/=(const ModInt& a){
        *this *= a.inv();
        return *this;
    }
    constexpr ModInt operator-() const {
        return ModInt(-x);
    }
    constexpr ModInt operator+(const ModInt& a) const {
        return ModInt(*this) += a;
    }
    constexpr ModInt operator-(const ModInt& a) const {
        return ModInt(*this) -= a;
    }
    constexpr ModInt operator*(const ModInt& a) const {
        return ModInt(*this) *= a;
    }
    constexpr ModInt operator/(const ModInt& a) const {
        return ModInt(*this) /= a;
    }
    constexpr ModInt operator++(){
        *this += ModInt(1);
        return *this;
    }
    constexpr ModInt operator++(int){
        ModInt old = *this;
        ++*this;
        return old;
    }
    constexpr ModInt operator--(){
        *this -= ModInt(1);
        return *this;
    }
    constexpr ModInt operator--(int){
        ModInt old = *this;
        --*this;
        return old;
    }
    constexpr bool operator==(const ModInt& a) const {
        return x == a.x;
    }
    constexpr bool operator!=(const ModInt& a) const {
        return x != a.x;
    }
    constexpr ModInt pow(int64 r) const {
        if(!r)return 1;
        ModInt res = pow(r>>1);
        res *= res;
        if(r & 1) res *= *this;
        return res;
    }
    constexpr ModInt inv() const {
        return pow(mod-2);
    }
    friend istream& operator>>(istream& is, ModInt& a){
        int64 t;
        is >> t;
        a = ModInt(t);
        return is;
    }
    friend ostream& operator<<(ostream& os, const ModInt& a){
        return os << a.x;
    }
};
using mint = ModInt<MOD>;

vector<mint> fact;
vector<mint> revfact;
mint comb(int32 n, int32 r){
  return fact[n] * revfact[r] * revfact[n-r];
}

vector<vector<int32>> adj;
vector<int32> cnt;

int32 dfs(int32 v, int32 p = -1){
  for(int32 u : adj[v]){
    if(u == p)continue;
    cnt[v] += dfs(u,v);
  }
  return ++cnt[v];
}

vector<mint> dp;

mint dfs2(int32 v, int32 p = -1){
  dp[v] *= fact[cnt[v]-1];
  for(int32 u : adj[v]){
    if(u == p)continue;
    dp[v] *= dfs2(u,v);
    dp[v] *= revfact[cnt[u]];
  }
  return dp[v];
}

void dfs3(int32 v, int32 p = -1){
  for(int32 u : adj[v]){
    if(u == p)continue;
    mint x = dp[v] / dp[u] / comb(cnt[0]-1, cnt[u]);
    dp[u] *= x;
    dp[u] *= comb(cnt[0]-1, cnt[0] - cnt[u]);
    dfs3(u,v);
  }
}

int main(){
  cin.tie(0);
  ios::sync_with_stdio(false);
  int32 n;
  cin >> n;
  adj.resize(n);
  REP(i,n-1){
    int32 a,b;
    cin >> a >> b;
    --a;--b;
    adj[a].pb(b);
    adj[b].pb(a);
  }
  cnt.resize(n,0);
  dfs(0);
  fact.resize(n+1,1);
  REP(i,n){
    fact[i+1] = fact[i] * (i+1);
  }
  revfact.resize(n+1);
  revfact[n] = fact[n].inv();
  FORR(i,n-1,0){
    revfact[i] = revfact[i+1] * (i+1);
  }
  dp.resize(n,1);
  dfs2(0);
  // REP(i,n)ANS(dp[i]);
  dfs3(0);
  REP(i,n)ANS(dp[i]);
  return 0;
}

Measured memory_bytes: 20976