#include<iostream>
#include<vector>
#include<algorithm>
#include<string>
#include<queue>
#include<cmath>
#include<cstdio>
#include<tuple>
#include<bitset>
#include<map>

using namespace std;
#define int long long
#define rep(i,n) for(int i=0;i<n;++i)
#define rep1(i,n) for(int i=1;i<=n;++i)
#define ALL(x) x.begin(),x.end()
#define ll long long
typedef pair<int,int> P;
const int inf=1000000007;
const int MOD=1000000007;
struct Nums{
    long long n;
    vector<long long> kaijo;
    void build(int N){
        n=N;
        kaijo.push_back(1);
        for(long long i=1;i<=n;i++){
            kaijo.push_back((kaijo[i-1]*i)%MOD);
        }
    }
    long myPow(long x, long n, long m){
        if(n == 0)
            return 1;
        if(n % 2 == 0)
            return myPow(x * x % m, n / 2, m);
        else
            return x * myPow(x, n - 1, m) % m;
    }
    long long modinv(long long a, long long m) {
        long long b = m, u = 1, v = 0;
        while (b) {
            long long t = a / b;
            a -= t * b; swap(a, b);
            u -= t * v; swap(u, v);
        }
        u %= m;
        if (u < 0) u += m;
        return u;
    }
    long long comb(long long N,long long K,long long rest){
        long long res=kaijo[N]*modinv(kaijo[K],rest)%rest;
        res*=modinv(kaijo[N-K],rest);
        res%=rest;
        return res;
    }
};
Nums lib;
struct Node{
    int no;
    int par;
    int sum;
    int P;
    int top;
    vector<Node*> child;
    void build(int i){
        no=i;
        par=i;
        sum=1;
        P=1;
        top=1;
    }
};
struct Tree{
    int n;
    vector<Node> node;
    Tree(int k){
        n=k;
        node.resize(n+1);
        for(int i=1;i<=n;++i){
            node[i].build(i);
        }
    }
    void input(int k){
        for(int i=0;i<k;++i){
            int a,b;cin>>a>>b;
            node[a].child.push_back(&node[b]);
            node[b].child.push_back(&node[a]);
        }
    }
    void BFS(int s){
        queue<Node> que;
        que.push(node[s]);
        while(!que.empty()){
            Node buf=que.front();que.pop();
            int num=buf.child.size();
            for(int i=0;i<num;++i){
                if(buf.child[i]->no!=buf.par){
                    buf.child[i]->par=buf.no;
                    que.push(*buf.child[i]);
                }
            }
        }
    }
    void DFS(Node& node){
        if(node.child.size()==1&&node.par!=node.no){
            return;
        }
        else{
            int num=node.child.size();
            int div=1;
            int mul=1;
            int Sum=0;
            for(int i=0;i<num;++i){
                if(node.child[i]->no!=node.par){
                    DFS(*node.child[i]);
                    mul*=node.child[i]->P;
                    mul%=MOD;
                    Sum+=node.child[i]->sum;
                    div*=lib.kaijo[node.child[i]->sum];
                    div%=MOD;
                }
            }
            mul*=lib.kaijo[Sum];
            mul%=MOD;
            mul*=lib.modinv(div,MOD);
            mul%=MOD;
            node.P=mul;
            node.sum=Sum+1;
        }
    }
    void BFS2(int s){
        queue<Node> que;
        que.push(node[s]);
        int one=node[1].top;
        while(!que.empty()){
            Node buf=que.front();que.pop();
            int num=buf.child.size();
            int ans=1;
            ans=node[buf.par].top;
            ans*=lib.kaijo[buf.sum];
            ans%=MOD;
            ans*=lib.kaijo[n-1-buf.sum];
            ans%=MOD;
            ans*=lib.modinv(lib.kaijo[n-1],MOD);
            ans%=MOD;
            ans*=lib.modinv(buf.P,MOD);
            ans%=MOD;

            ans*=lib.kaijo[n-1];
            ans%=MOD;
            ans*=lib.modinv(lib.kaijo[n-buf.sum],MOD);
            ans%=MOD;
            int subnum=n-buf.sum;
            for(int i=0;i<num;++i){
                if(buf.child[i]->no!=buf.par){
                    ans*=buf.child[i]->P;
                    ans%=MOD;
                    ans*=lib.modinv(lib.kaijo[buf.child[i]->sum],MOD);
                    ans%=MOD;
                    que.push(*buf.child[i]);
                }
            }
            node[buf.no].top=ans;
            if(buf.no==1){
                node[1].top=one;
                node[1].P=one;
            }
        }
    }
};
signed main(){
  int n;cin>>n;
  Tree tree(n);
  lib.build(n+5);
  tree.input(n-1);
  tree.BFS(1);
  tree.DFS(tree.node[1]);
  tree.node[1].top=tree.node[1].P;
  tree.BFS2(1);
  rep1(i,n){
      cout<<tree.node[i].top<<"\n";
  }
  return 0;
}

Measured memory_bytes: 43092