// 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: 1.4537687330002789x):
#include <bits/stdc++.h>

#define LL long long

using namespace std;

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

const int maxn = (int)2e5 + 10;

LL f[maxn];

LL qp(LL a, int b){

    LL res = 1;

    while(b){

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

        b >>= 1; (a *= a) %= mod;

    }

    return res;

}

inline LL inv(LL a){

    return qp(a, mod - 2);

}

LL fac[maxn], ifac[maxn];

inline LL C(int n, int m){

    if(n >= m && m >= 0) return fac[n] * ifac[m] % mod * ifac[n - m] % mod;

    else return 0;

}

int siz[maxn];

vector <int> edg[maxn];

void dfs1(int u, int fa){

    siz[u] = 1; f[u] = 1;

    for(auto v : edg[u]){

        if(v != fa){

            dfs1(v, u);

            siz[u] += siz[v];

        }

    }

    int s = siz[u] - 1;

    for(auto v : edg[u]){

        if(v != fa){

            (f[u] *= C(s, siz[v]) * f[v] % mod) %= mod;

            s -= siz[v];

        }

    }

}

LL ans[maxn];

void dfs2(int u, int fa){

    LL oldfu = f[u], oldsu = siz[u];

    ans[u] = f[u];

    for(auto v : edg[u]){

        if(v != fa){

            (f[u] *= inv(C(siz[u] - 1, siz[v])) * inv(f[v]) % mod) %= mod;

            LL oldfv = f[v], oldsv = siz[v];

            siz[u] = siz[u] - siz[v];

            siz[v] += siz[u];

            (f[v] *= C(siz[v] - 1, siz[u]) * f[u] % mod) %= mod;

            dfs2(v, u);

            f[v] = oldfv; siz[v] = oldsv;

            f[u] = oldfu; siz[u] = oldsu;

        }

    }

}

int main(){

    ios::sync_with_stdio(false);

    int n; cin>>n;

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

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

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

        ifac[i] = inv(fac[i]);

    }

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

        int a, b; cin>>a>>b;

        edg[a].push_back(b);

        edg[b].push_back(a);

    }

    dfs1(1, 0);

    dfs2(1, 0);

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

    return 0;

}