import std.stdio, std.conv, std.string, std.array, std.range, std.algorithm, std.container;
import std.math, std.random, std.bigint, std.datetime, std.format;
void main(string[] args){ if(args.length > 1) if(args[1] == "-debug") DEBUG = 1; solve(); } bool DEBUG = 0; 
void log(A ...)(lazy A a){ if(DEBUG) print(a); }
void print(){ writeln(""); } void print(T)(T t){ writeln(t); } void print(T, A ...)(T t, A a){ write(t, " "), print(a); }
string unsplit(T)(T xs){ return xs.array.to!(string[]).join(" "); }
string scan(){ static string[] ss; while(!ss.length) ss = readln.chomp.split; string res = ss[0]; ss.popFront; return res; }
T scan(T)(){ return scan.to!T; } T[] scan(T)(int n){ return n.iota.map!(i => scan!T()).array; }
T lowerTo(T)(ref T x, T y){ if(x > y) x = y; return x; } T raiseTo(T)(ref T x, T y){ if(x < y) x = y; return x; }

// ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- //

void solve(){
    int n = scan!int;
    Node[] nodes;
    foreach(i; 0 .. n) nodes ~= new Node(i);
    foreach(_; 0 .. n - 1){
        int a = scan!int - 1, b = scan!int - 1;
        nodes[a].connectTo(nodes[b]);
    }

    foreach(ed; nodes[0].edgesIn) ed.calcIn;
    nodes[0].calc;
    foreach(ed; nodes[0].edgesOut) ed.calcOut;

    foreach(nd; nodes) nd.value.print;
}

// 双方向木DP

class Node{
    int id;
    Finite value;
    long cnt;
    Edge[] edgesIn, edgesOut;
    this(int id){
        this.id = id;
    }
    void connectTo(Node nd){
        Edge edIn = new Edge(nd, this);
        Edge edOut = new Edge(this, nd);
        edIn.inv = edOut, edOut.inv = edIn;
        this.edgesIn ~= edIn, this.edgesOut ~= edOut;
        nd.edgesIn ~= edOut, nd.edgesOut ~= edIn;
    }
    void calc(){
        log("calc node", id);
        value = Finite(1);
        cnt = 0;
        foreach(ed; edgesIn){
            ed.inv.value = value;
            ed.inv.cnt = cnt;
            value *= pascal(cnt, ed.cnt) * ed.value;
            cnt += ed.cnt;
        }

        value = Finite(1);
        cnt = 0;
        foreach_reverse(ed; edgesIn){
            ed.inv.value *= pascal(ed.inv.cnt, cnt) * value;
            ed.inv.cnt += cnt + 1;
            value *= pascal(cnt, ed.cnt) * ed.value;
            cnt += ed.cnt;
        }
    }
}
class Edge{
    static int nextId = 0;
    int id;
    Node node0, node1;
    Edge inv;
    Finite value;
    long cnt;
    this(Node node0, Node node1){
        this.id = nextId ++;
        this.node0 = node0;
        this.node1 = node1;
    }
    void calcIn(){
        log("calcin edge", id);
        foreach(ed; node0.edgesIn) if(ed.node0.id != this.node1.id){
            ed.calcIn;
        }
        calc;
    }
    void calcOut(){
        log("calcout edge", id);
        node1.calc;
        foreach(ed; node1.edgesOut) if(ed.node1.id != this.node0.id){
            ed.calcOut;
        }
    }
    void calc(){
        value = Finite(1);
        cnt = 0;
        foreach(ed; node0.edgesIn) if(ed.node0.id != this.node1.id){
            value *= pascal(cnt, ed.cnt) * ed.value;
            cnt += ed.cnt;
        }
        cnt += 1;
    }

}

// 素数位数有限体
// 負の数を与えても大丈夫（Finite(-1) などは Finite(mod - 1) の意味になる）
import std.conv;
struct Finite{
	long value; static long mod = 1_000_000_007;
	this(long v){ value = val(v); }
	static long val(long v){ return (v + mod  - (v / mod) * mod) % mod; }
	bool opCast(T: bool)(){ return value != 0; }
	bool opEquals(Finite b){ return(value == b.value); }
	string toString(){ return value.to!string; }

	Finite opUnary(string s){ long v;
		if(s == "+") v = value;
		else if(s == "-") v = mod - value;
		else if(s == "++") v = value + 1;
		else if(s == "--") v = value + mod - 1;
		else assert(0, "Operator unary " ~ s ~ " not implemented");
		return Finite(v);
	}

	Finite opBinary(string s)(Finite b){ return opBinary!s(b.value); }
	Finite opBinary(string s)(long u){ long v;
		if(s == "+") v = value + u;
		else if(s == "-") v = value + mod - u;
		else if(s == "*") v = value * u;
		else if(s == "/") v = value * inv(u);
		else assert(0, "Operator " ~ s ~ " not implemented");
		return Finite(v);
	}
	Finite opBinaryRight(string s)(long u){ long v;
		if(s == "+") v = u + value;
		else if(s == "-") v = u + mod - value;
		else if(s == "*") v = u * value;
		else if(s == "/") v = u * invvalue;
		else assert(0, "Operator " ~ s ~ " not implemented");
		return Finite(v);
	}
	Finite opAssign(long v){ value = v; return this; }

	Finite opOpAssign(string s)(Finite b){ return opOpAssign!s(b.value); }
	Finite opOpAssign(string s)(long v){
		if(s == "+") value = (value + v) % mod;
		else if(s == "-") value = (value + mod - v) % mod;
		else if(s == "*") value = (value * v) % mod;
		else if(s == "/") value = (value * inv(v)) % mod;
		else assert(0, "Operator " ~ s ~ "= not implemented");
		return this;
	}
	
	private static long[] _inv = [0, 1];
	long invvalue(){ return inv(value); }
	long inv(long v){ int i = val(v).to!int;
		while(i >= _inv.length){
			_inv ~= _inv[(mod % $).to!int] * (mod - mod / _inv.length) % mod;
		}
		return _inv[i];
	}
	
}

// ---以下はユーティリティ--- //

/// mod p における累乗
/// 例 power(5, 3) = Finite(125)
/// オーダーは a ** b を計算する場合 O(log b)
Finite power(long a, long b){
	Finite m = Finite(a);
	Finite ans = Finite(1);
	while(b > 0){
		if(b % 2) ans = m;
		m *= m;
		b /= 2;
	}
	return ans;
}
Finite power(Finite a, long b){ return power(a.value, b); }

/// mod p における階乗
/// 例 perm(6) = Finite(120)
/// オーダーはプログラム全体で出てくる最大の引数Nに対してO(N)
Finite perm(long x){ int i = Finite.val(x).to!int;
	static Finite[] _perm = [];
	if(_perm.length == 0) _perm ~= Finite(1);
	while(i >= _perm.length) _perm ~= _perm[$ - 1] * _perm.length;
	return _perm[i];
}

/// mod p における階乗の逆元
/// 例 invperm(6) = Finite(1) / Finite(120)
/// オーダーはプログラム全体で出てくる最大の引数Nに対してO(N)
/// ※ invperm(x) と inv(perm(x)) は同じ値だが、後者は計算量が O(mod) になる
Finite invperm(long x){ int i = Finite.val(x).to!int;
	static Finite[] _iperm = [];
	if(_iperm.length == 0) _iperm ~= Finite(1);
	while(i >= _iperm.length) _iperm ~= _iperm[$ - 1] / _iperm.length;
	return _iperm[i];
}

/// mod p における二項係数（定義に注意：(a + b)! / a! / b! ）
/// 例 pascal(3, 2) = Finite(10)
/// ただし、「a < 0 または b < 0」のとき答えは 0 を返します。
Finite pascal(long a, long b){
	if(a < 0 || b < 0) return Finite(0);
	return perm(a + b) * invperm(a) * invperm(b);
}
