#include<bits/stdc++.h>
#define rep(i,a,...) for(int i = (a)*(strlen(#__VA_ARGS__)!=0);i<(int)(strlen(#__VA_ARGS__)?__VA_ARGS__:(a));++i)
#define per(i,a,...) for(int i = (strlen(#__VA_ARGS__)?__VA_ARGS__:(a))-1;i>=(int)(strlen(#__VA_ARGS__)?(a):0);--i)
#define foreach(i, n) for(auto &i:(n))
#define pii pair<int, int>
#define pll pair<long long, long long>
#define all(x) (x).begin(), (x).end()
#define bit(x) (1ll << (x))
using ll = long long;
const ll MOD = (ll)1e9+7;
//const ll MOD = 998244353;
const int INF = (ll)1e9+7;
const ll INFLL = (ll)1e18;
using namespace std;
template<class t>
using vvector = vector<vector<t>>;
template<class t>
using vvvector = vector<vector<vector<t>>>;
template<class t>
using priority_queuer = priority_queue<t, vector<t>, greater<t>>;
template<class t, class u> bool chmax(t &a, u b){if(a<b){a=b;return true;}return false;}
template<class t, class u> bool chmin(t &a, u b){if(a>b){a=b;return true;}return false;}
#ifdef DEBUG
#define debug(x) cout<<"LINE "<<__LINE__<<": "<<#x<<" = "<<x<<endl;
#else
#define debug(x) (void)0
#endif

ll modpow(ll x, ll b){
  ll res = 1;
  while(b){
    if(b&1)res = res * x % MOD;
    x = x * x % MOD;
    b>>=1;
  }
  return res;
}

ll modinv(ll x){
  return modpow(x, MOD-2);
}

bool was_output = false;
template<class t>
void output(t a){
  if(was_output)cout << " ";
  cout << a;
  was_output = true;
}
void outendl(){
  was_output = false;
  cout << endl;
}
ll in(){
  ll res;
  scanf("%lld", &res);
  return res;
}

template<class t>
istream& operator>>(istream&is, vector<t>&x){
  for(auto &i:x)is >> i;
  return is;
}

template<class t, class u>
istream& operator>>(istream&is, pair<t, u>&x){
  is >> x.first >> x.second;
  return is;
}

template<class t>
void in(t&x){
  cin >> x;
}

template<class t>
void out(t x){
  cout << x;
}


template<long long mod>
class modint{
	public:
		long long x;
		modint(long long a){x=a%mod;if(x<0)x+=mod;}
		modint(){x=0;}

		modint pow(long long a){
			modint res(1), b(x);
			while(a){
				if(a&1)res*=b;
				b*=b;
				a>>=1;
			}
			return res;
		}

		modint inv(){return pow(mod-2);}

		modint& operator+=(modint a){x=(x+a.x)%mod;return *this;}
		modint& operator-=(modint a){x=x-a.x;if(x<0)x+=mod;return *this;}
		modint& operator*=(modint a){x=x*a.x%mod;return *this;}
		modint& operator/=(modint a){x=x*a.inv().x%mod;return *this;}

		modint operator+(modint a){return modint(x)+=a;}
		modint operator-(modint a){return modint(x)-=a;}
		modint operator*(modint a){return modint(x)*=a;}
		modint operator/(modint a){return modint(x)/=a;}

		modint operator-(){return modint(x);}

		bool operator==(const modint a){return x == a.x;}
		bool operator<(const modint a){return x < a.x;}
		bool operator>(const modint a){return x > a.x;}
};

template<long long mod>
ostream& operator<<(ostream& os, const modint<mod>& a){
	os << a.x;
	return os;
}

using mint = modint<MOD>;

int n;
vvector<pii> edges;

mint factorial(int x){
  static vector<mint> dp;
  if(dp.empty()){
    dp.resize(2e5+10);
    dp[0]=1;
    dp[1]=1;
    rep(i,dp.size()-1){
      dp[i+1] = dp[i] * (i+1);
    }
  }
  if(x<=1)return 1;
  return dp[x];
}

mint factorial_inv(int x){
  static vector<mint> dp;
  if(dp.empty()){
    dp.resize(2e5+10);
    dp[2e5+5] = factorial(2e5+5).inv();
    per(i,2e5+5){
      dp[i] = dp[i+1] * (i+1);
    }
  }
  if(x<=1)return 1;
  return dp[x];
}
using P = pair<int,mint>;

P func(int place,int last){
  static vvector<P> dp(2e5+10);
  static vvector<bool> used(2e5+10);
  if(dp[place].empty()){
    dp[place].resize(edges[place].size());
    used[place].resize(edges[place].size(),false);
  }
  if(last>=0)if(used[place][last])return dp[place][last];
  P res(0,1);
  rep(i,edges[place].size()){
    if(i==last)continue;
    P m = func(edges[place][i].first,edges[place][i].second);
    res.first += m.first;
    res.second *= m.second;
    res.second *= factorial_inv(m.first);
  }
  res.second *= factorial(res.first);
  ++res.first;

  if(last>=0){
    used[place][last] = true;
    dp[place][last] = res;
  }else{
    rep(i,edges[place].size()){
      P m = func(edges[place][i].first,edges[place][i].second);
      P co = res;
      --co.first;
      co.second *= factorial_inv(co.first);
      co.second *= factorial(m.first);
      co.second /= m.second;
      co.first -= m.first;
      co.second *= factorial(co.first);
      ++co.first;
      used[place][i] = true;
      dp[place][i] = co;
    }
  }
  return res;
}

void setup(){
  n = in();
  edges.resize(n);
  rep(i,n-1){
    int a = in() - 1;
    int b = in() - 1;
    edges[a].emplace_back(b,edges[b].size());
    edges[b].emplace_back(a,edges[a].size()-1);
  }
}

int main(){
  setup();
  vector<mint> anses(n);
  vector<pii> line;
  rep(i,n){
    line.emplace_back(edges[i].size(),i);
  }
  sort(all(line),[](pii a,pii b){return a.first>b.first;});
  foreach(i,line){
    anses[i.second] = func(i.second,-1).second;
  }

  rep(i,n){
    cout << anses[i] << endl;
  }
  return 0;
}


Measured memory_bytes: 49136