#include <bits/stdc++.h>
using namespace std;
#define REP(i,a,n) for(int i=(a); i<(int)(n); i++)
#define rep(i,n) REP(i,0,n)
#define FOR(it,c) for(__typeof((c).begin()) it=(c).begin(); it!=(c).end(); ++it)
#define ALLOF(c) (c).begin(), (c).end()
typedef long long ll;
typedef unsigned long long ull;

static const long long mod = 1000000007;
struct mint {
  long long x;
  mint(ll x = 0):x(x%mod) {}
  mint& operator+=(const mint a) {
    (x += a.x) %= mod;
    return *this;
  }
  mint& operator-=(const mint a) {
    (x += mod-a.x) %= mod;
    return *this;
  }
  mint& operator*=(const mint a) {
    (x *= a.x) %= mod;
    return *this;
  }
  mint operator+(const mint a) const {
    mint ret(*this);
    return ret += a;
  }
  mint operator-(const mint a) const {
    mint ret(*this);
    return ret -= a;
  }
  mint operator*(const mint a) const {
    mint ret(*this);
    return ret *= a;
  }
  mint pow(ll t) const {
    if(t==0) return mint(1);
    mint a = pow(t>>1);
    a *= a;
    if(t&1) a *= *this;
    return a;
  }
  
  //for prime mod
  mint inv() const {
    return pow(mod-2);
  }
  mint& operator/=(const mint a) {
    return (*this) *= a.inv();
  }
  mint operator/(const mint a) const {
    mint ret(*this);
    return ret /= a;
  }
};
ostream &operator<<(ostream& os, const mint& x) {
  os << x.x;
  return os;
}
class modutils {
  vector<mint> fact, invfact;
public:
  modutils(int n = 200005):fact(n+1),invfact(n+1) {
    fact[0] = 1;
    for(int i=1; i<=n; i++) fact[i] = fact[i-1] * i;
    invfact[n] = fact[n].inv();
    for(int i=n; i>=1; i--) invfact[i-1] = invfact[i] * i;
  }
  mint pow(mint x, ll n) {
    return x.pow(n);
  }
  mint comb(ll n, ll k) {
    if(n<0 || k<0 || n<k) return 0;
    return fact[n] * invfact[k] * invfact[n-k];
  }
  mint perm(ll n, ll k) {
    if(n<0 || k<0 || n<k) return 0;
    return fact[n] * invfact[n-k];
  }
  mint fac(ll n) {
    return fact[n];
  }
};
modutils mutil;


class Rerooting {
public:
  struct ST {
    int src, dst;
    int cn;
    mint cnt;
    int rev;
  };
  
private:
  int N;
  vector<vector<ST>> G;

  void dfs(int v, int p, ST& e){
    vector<int> cns;
    mint ret(1);
    
    rep(i,G[v].size()){
      if(G[v][i].dst == p) continue;
      
      if(G[v][i].cn == -1){
        dfs(G[v][i].dst, v, G[v][i]);
      }
      
      cns.push_back(G[v][i].cn);
      ret *= G[v][i].cnt;
    }

    if(cns.size() == 0){
      e.cn = 1;
      e.cnt = ret;
    }else{
      int sum = 0;
      rep(i,cns.size()){
        sum += cns[i];
      }
      mint tmp = mutil.fac(sum);
      rep(i,cns.size()){
        tmp /= mutil.fac(cns[i]);
      }
      e.cn = sum + 1;
      e.cnt = ret * tmp;
    }
  }

  void bfs(int root){
    queue<pair<int,int>> que;
    que.push(make_pair(root,-1));
    
    while(!que.empty()){
      pair<int,int> pr = que.front(); que.pop();
      int v = pr.first;
      int p = pr.second;
      
      int sum = 0;
      mint ret(1);
      mint pp(1);
      rep(i,G[v].size()){
        sum += G[v][i].cn;
        ret *= G[v][i].cnt;
        pp *= mutil.fac(G[v][i].cn);
      }
      
      rep(i,G[v].size()){
        int tsum = sum - G[v][i].cn;
        mint tret = ret / G[v][i].cnt;
        mint ttmp = mutil.fac(tsum);
        ttmp /= pp / mutil.fac(G[v][i].cn);
        
        G[G[v][i].dst][G[v][i].rev].cn = tsum + 1;
        G[G[v][i].dst][G[v][i].rev].cnt = tret * ttmp;
      }
      
      rep(i,G[v].size()){
        if(G[v][i].dst == p) continue;
        que.push(make_pair(G[v][i].dst,v));
      }
    }
  }
  
public:
  Rerooting(int N):N(N),G(N, vector<ST>()){}

  void add_edge(int a, int b){
    G[a].push_back((ST){a,b,-1,0,(int)(G[b].size())});
    G[b].push_back((ST){b,a,-1,0,(int)(G[a].size()-1)});
  }
  
  void solve(){
    int root = 0;
    ST st = (ST){-1,root,-1,0,-1};
    dfs(root, -1, st);
    bfs(root);
  }

  mint get_ans(int v){
    ST st = (ST){-1,v,-1,0,-1};
    dfs(v, -1, st);
    return st.cnt;
  }
};

int main(){
  int N;
  cin >> N;
  Rerooting reroot(N);
  rep(i,N-1){
    int a, b;
    cin >> a >> b;
    a--;
    b--;
    reroot.add_edge(a,b);
  }

  reroot.solve();
  
  rep(i,N){
    cout << reroot.get_ans(i) << endl;
  }
  
  return 0;
}


Measured memory_bytes: 29544