#include <bits/stdc++.h>
#define REP(i, n) for(int i=0; i<(int)(n); i++)
#define REP1(i,a,b) for(int i=a; i<=(int)(b); i++)
#define ALL(x) begin(x),end(x)
#define PB push_back
using namespace std;
typedef int64_t LL;
typedef vector<int> VI;
typedef pair<int,int> PII;

template<class T> inline bool chmax( T &a, const T &b ) { return b>a ? a=b,true : false; }
template<class T> inline bool chmin( T &a, const T &b ) { return b<a ? a=b,true : false; }
template<class T> using MaxHeap = priority_queue<T>;
template<class T> using MinHeap = priority_queue<T, vector<T>, greater<T>>;
template<class T, class F=less<T>> void sort_uniq( vector<T> &v, F f=F() ) {
    sort(begin(v),end(v),f);
    v.resize(unique(begin(v),end(v))-begin(v));
}
// {{{ ModInt
template<int _MOD>
struct ModInt {
	static const auto MOD = _MOD;
	template<class T> using integral_only = typename enable_if<is_integral<T>::value>::type;

    int x;   
	constexpr ModInt() : x() {}

	template<class T, integral_only<T>* = nullptr>
    ModInt(T _x=0) {
		x = _x % MOD;
		if(x<0) x+=MOD;
	}
    ModInt operator-() const { return {x == 0? 0 : MOD-x}; }
    ModInt& operator+=(const ModInt a) {
        if ((x += a.x) >= MOD) x -= MOD;
        return *this;
    }
    ModInt& operator-=(const ModInt a) {
        if ((x += MOD-a.x) >= MOD) x -= MOD;
        return *this;
    }
    ModInt& operator*=(const ModInt a) {
        x = (long long)x * a.x % MOD;
        return *this;
    }
    ModInt& operator/=(const ModInt a) {
        return (*this) *= a.inv();
    }

    ModInt operator+(const ModInt a) const { return ModInt(*this) += a; }
    ModInt operator-(const ModInt a) const { return ModInt(*this) -= a; }
    ModInt operator*(const ModInt a) const { return ModInt(*this) *= a; }
    ModInt operator/(const ModInt a) const { return ModInt(*this) /= a; }
    ModInt inv() const {
	    // for prime MOD
        return pow(MOD-2);
    }
	ModInt inv2() const {
		// work for non-prime MOD if gcd(x,MOD) = 1
		int a = x, b = MOD, u = 1, v = 0;
		while(b != 0) {
			int t = a / b;
			a -= t * b;
			u -= t * v;
			swap(a, b);
			swap(u, v);
		}
		return u;
	}
	template<class T, integral_only<T>* = nullptr>
    ModInt pow(T t) const {
		ModInt r = 1, p = *this;
		while(t) {
			if(t & 1) r *= p;
			p *= p;
			t >>= 1;
		}
        return r;
    }

    bool operator==(ModInt rhs) const { return x == rhs.x; }
    bool operator!=(ModInt rhs) const { return x != rhs.x; }
    bool operator<(ModInt rhs) const { return x < rhs.x; }
    bool operator<=(ModInt rhs) const { return x <= rhs.x; }
    bool operator>(ModInt rhs) const { return x > rhs.x; }
    bool operator>=(ModInt rhs) const { return x >= rhs.x; }

    friend string to_string(ModInt i) { return to_string(i.x); }
    friend istream& operator>>(istream&i,ModInt&a) { return i>>a.x; }
    friend ostream& operator<<(ostream&o,const ModInt&a) { return o<<a.x; }
};

const int MOD=1000000007;
using mint=ModInt<MOD>;
// }}}

const int N=2e5+5;
int n, sz[N];
VI e[N];
mint dp[N], ans[N], fact[N], ifact[N];

void init_fact() {
	fact[0]=1;
	for(int i=1; i<=n; i++) fact[i]=fact[i-1]*i;
	ifact[n]=fact[n].inv();
	for(int i=n; i>0; i--) ifact[i-1]=ifact[i]*i;
}
// dp[i] = (sz[i]-1)/(sz[j1]!)(sz[j2])!...*dp[j1]*dp[j2]*...
void go(int u, int p=-1) {
	sz[u]=1;
	for(int v:e[u]) {
		if(v==p) continue;
		go(v,u);
		sz[u]+=sz[v];
	}
	dp[u]=fact[sz[u]-1];
	for(int v:e[u]) {
		if(v==p) continue;
		dp[u]*=dp[v]*ifact[sz[v]];
	}
}

void go2(int u, int p=-1) {
	ans[u]=dp[u];
	for(int v:e[u]) {
		if(v==p) continue;
		dp[u]*=ifact[sz[u]-1]*dp[v].inv()*fact[sz[v]];
		sz[u]-=sz[v];
		dp[u]*=fact[sz[u]-1];

		dp[v]*=ifact[sz[v]-1];
		sz[v]+=sz[u];
		dp[v]*=fact[sz[v]-1]*dp[u]*ifact[sz[u]];
		go2(v, u);
		dp[v]*=ifact[sz[v]-1]*dp[u].inv()*fact[sz[u]];
		sz[v]-=sz[u];
		dp[v]*=fact[sz[v]-1];

		dp[u]*=ifact[sz[u]-1];
		sz[u]+=sz[v];
		dp[u]*=fact[sz[u]-1]*dp[v]*ifact[sz[v]];
	}
}

int main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
 	cin >> n;
 	init_fact();
 	REP(i,n-1) {
 		int u,v;
 		cin >> u >> v;
 		--u; --v;
 		e[u].PB(v);
 		e[v].PB(u);
 	}
 	go(0);
 	go2(0);
 	REP(i,n) cout << ans[i] << '\n';
    return 0;
}

Measured memory_bytes: 17908