// Original C++ solution (slower):
//#pragma GCC target("avx2")

//#pragma GCC optimize("O3")

 

//#include <x86intrin.h>

#include <algorithm>

#include <iostream>

#include <cstring>

#include <string>

#include <bitset> 

#include <vector>

#include <cmath>

#include <deque>

#include <queue>

#include <iomanip>

#include <stack>

#include <map>

#include <set>

//#include <ordered_set>

//#include <ext/pb_ds/assoc_container.hpp>

//#include <ext/pb_ds/tree_policy.hpp>

 

//using namespace __gnu_pbds;

using namespace std;

 

//template<typename T> using ordered_set = tree <T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;

     

#define F first

#define S second           

#define lb lower_bound               

#define ub upper_bound

#define pb push_back

#define pf push_front    

#define ppb pop_back

#define mp make_pair                                     

#define bpp __builtin_popcountll                                                                                        

#define sqr(x) ((x) * (x)) 

#define sz(x) (int)x.size()

#define all(x) x.begin(), x.end()

#define in insert

#define ppf pop_front

#define endl '\n'

//#define int long long

 

typedef unsigned long long ull;

typedef long long ll;

typedef long double ld;

typedef pair <int, int> pii;

 

const int mod = (int)1e9 + 7;

const int N = (int)3e5 + 123;

const ll inf = (ll)1e18 + 1;

 

const double pi = acos (-1.0);

const double eps = 1e-7;                  

const int dx[] = {0, 0, 1, 0, -1};

const int dy[] = {0, 1, 0, -1, 0};



int n, dp[N], sz[N], fact[N], inv[N];

vector <int> g[N];



inline int add (int a, int b) {

   a += b;

   if (a >= mod) a -= mod;

   if (a < 0) a += mod;

   return a;

}



inline int mult (int a, int b) {

   return 1ll * a * b % mod;

}



inline int binpow (int a, int b) {

   int res = 1;

   while (b) {

      if (b & 1) res = mult (res, a);

      a = mult (a, a);

      b >>= 1;

   }

   return res;

}



void dfs (int v = 1, int pr = 0) {

   sz[v] = 1;

   for (auto to : g[v]) {

      if (to != pr)

         dfs (to, v), sz[v] += sz[to];

   }

   dp[v] = fact[sz[v] - 1];

   for (auto to : g[v]) {

      if (to != pr) {

         dp[v] = mult (dp[v], mult (dp[to], inv[sz[to]]));

      }

   }

}



void recalc (int v = 1, int pr = 0) {

   if (v != 1) dp[v] = mult (mult (dp[pr], sz[v]), binpow (n - sz[v], mod - 2));

   for (auto to : g[v])

      if (to != pr)

         recalc (to, v);

}



inline void boost () {

   ios_base :: sync_with_stdio (0);

   cin.tie (0), cout.tie (0);

}

 

inline void Solve () {

   cin >> n;

   for (int i = 1; i < n; i ++) {

      int x, y;

      cin >> x >> y;

      g[x].pb (y);

      g[y].pb (x);

   }

   fact[0] = 1;

   for (int i = 1; i <= n; i ++) fact[i] = mult (fact[i - 1], i), inv[i] = binpow (fact[i], mod - 2);

   dfs ();

   recalc ();

   for (int i = 1; i <= n; i ++) cout << dp[i] << endl;

}            

 

signed main () {                                       

   #ifdef QWERTY

      freopen("input", "r", stdin);

   #endif

// freopen (".in", "r", stdin);    

// freopen (".out", "w", stdout);              

   boost ();

   int tt = 1;

   //cin >> tt;   

   while (tt --) {

      Solve ();

   }                                               

   return 0;      

}

// Optimized solution to the same problem (faster):
#include<bits/stdc++.h>

#define mod (1000000007)

using namespace std;



int n;

int num,fst[200010],lst[400010],to[400010];

int fa[200010],son[200010];

long long fac[200010],inv[200010],ans[200010];



long long ksm(long long a,long long b)

{

	long long res=1,sum=a;

	while(b)

	{

		if(b&1) (res*=sum)%=mod;

		(sum*=sum)%=mod;

		b>>=1;

	}

	return res;

}



inline void insert(int u,int v)

{

	lst[++num]=fst[u];to[num]=v;fst[u]=num;

	lst[++num]=fst[v];to[num]=u;fst[v]=num;

}



void dfs(int x)

{

	son[x]=1;

	for(int i=fst[x];i;i=lst[i]) if(fa[x]!=to[i])

	{

		fa[to[i]]=x;

		dfs(to[i]);

		son[x]+=son[to[i]];

	}

}



void work(int x)

{

	int cnt=0;

	ans[x]=1;

	for(int i=fst[x];i;i=lst[i]) if(fa[x]!=to[i])

	{

		work(to[i]);

		ans[x]=ans[x]*ans[to[i]]%mod*fac[son[x]-cnt-1]%mod*inv[son[to[i]]]%mod*inv[son[x]-cnt-1-son[to[i]]]%mod;

		cnt+=son[to[i]];

	}

}



void dfs2(int x,long long d)

{

	if(x!=1) ans[x]=ans[x]*fac[n-1]%mod*inv[n-son[x]]%mod*inv[son[x]-1]%mod*d%mod;

	long long re;

	for(int i=fst[x];i;i=lst[i]) if(fa[x]!=to[i])

	{

		re=ans[x]*ksm(ans[to[i]],mod-2)%mod*fac[son[to[i]]]%mod*fac[n-1-son[to[i]]]%mod*inv[n-1]%mod;

		dfs2(to[i],re);

	}

}



int main()

{

	int u,v;

	scanf("%d",&n);

	fac[0]=inv[0]=1;

	for(int i=1;i<=n;i++)

	{

		fac[i]=fac[i-1]*i%mod;

		inv[i]=ksm(fac[i],mod-2);

	}

	for(int i=1;i<n;i++)

	{

		scanf("%d%d",&u,&v);

		insert(u,v);

	}

	dfs(1);

	work(1);

	dfs2(1,0);

	for(int i=1;i<=n;i++) printf("%lld\n",ans[i]);

	return 0;

}

// Fastest known solution for this problem: