// Slower C++ solution:
//#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;      

}

// Faster C++ solution for the same problem (measured speedup: 5.269209554130634x):
#include <cmath>

#include <cstdio>

#include <cstdlib>

#include <cstring>

#include <iostream>

#include <algorithm>

#define mod ((int)1e9+7)

#define MAXN 200010

using namespace std;

typedef long long ll;

int n;

ll mod_pow(ll a,ll x){

    ll ret=1;

    while(x){

        if(x&1) ret=ret*a%mod;

        x>>=1;

        a=a*a%mod;

    }

    return ret;

}

ll fac[200010],inv[200010];

void pre(){

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

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

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

       // cout<<fac[i]<<endl;

    }

    inv[n]=mod_pow(fac[n],mod-2);

    for(int i=n-1;i>=0;i--) inv[i]=inv[i+1]*(i+1)%mod;

}

ll C(int N,int M){

    return fac[N]*inv[M]%mod*inv[N-M]%mod; 

}

int head[MAXN],cnt;

struct Edg{

    int to,nxt;

}e[MAXN<<1];

void add_e(int u,int v){

    e[++cnt].to=v;

    e[cnt].nxt=head[u];

    head[u]=cnt;

}

ll f[MAXN];

int sz[MAXN];

void getsize(int u,int fa){

    sz[u]=1;

    if(head[u]==-1) return;

    for(int i=head[u];i!=-1;i=e[i].nxt){

        if(e[i].to==fa) continue;

        getsize(e[i].to,u);

        sz[u]+=sz[e[i].to];

    }

}

void dfs(int u,int fa){

    f[u]=1;

    if(head[u]==-1) return;

    int son_sz=sz[u]-1,son;

    for(int i=head[u];i!=-1;i=e[i].nxt){

        son=e[i].to;

        if(son==fa) continue;

        dfs(son,u);

        f[u]=f[u]*f[son]%mod*C(son_sz,sz[son])%mod;

        son_sz-=sz[son];

    }

}

void pushdown(int x,int fa){

    if(fa){

        //cout<<"x= "<<x<<" "<<endl;

        //cout<<"C:"<<C(n-1,sz[x])<<" "<<f[x]<<endl;

        //cout<<"adfa ="<<mod_pow(C(n-1,sz[x])*f[x]%mod,mod-2)<<endl;

            f[x]=f[x]*f[fa]%mod*mod_pow(C(n-1,sz[x])*f[x]%mod,mod-2)%mod*C(n-1,n-sz[x])%mod;

        }

    if(head[x]==-1) return;

    int son;

    for(int i=head[x];i!=-1;i=e[i].nxt){

        son=e[i].to; if(son==fa) continue;

        pushdown(son,x);

    }

}

int main(){

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

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

    scanf("%d",&n);

    pre();

    memset(head,-1,sizeof(head));

    int u,v;

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

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

        add_e(u,v);

        add_e(v,u);

    }

    getsize(1,0);

    dfs(1,0);

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

    //    cout<<"i= "<<i<<" "<<f[i]<<" "<<sz[i]<<endl;

   // }

    pushdown(1,0);

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

        printf("%lld\n",f[i]);

    }

}