#include <bits/stdc++.h>
using namespace std;

template <typename T>
class Factrial
{
    vector<T> fact;
    vector<T> ifact;

public:
    Factrial(long long n) : fact(n + 1), ifact(n + 1)
    {
        this->fact[0] = T(1);
        for (long long i = 1; i <= n; ++i)
        {
            this->fact[i] = this->fact[i - 1] * i;
        }
        this->ifact[n] = T(1) / this->fact[n];
        for (long long i = n; i > 0; i--)
        {
            this->ifact[i - 1] = this->ifact[i] * i;
        }
    }
    T operator()(long long n, long long k)
    {
        if (k < 0 || k > n)
        {
            return T(0);
        }
        return this->fact[n] * this->ifact[k] * this->ifact[n - k];
    }

    T get_fact(long long n) const
    {
        if (n <= 0)
        {
            return 1;
        }
        return this->fact[n];
    }

    T get_ifact(long long n) const
    {
        if (n <= 0)
        {
            return 1;
        }
        return this->ifact[n];
    }
};

template <long long mod>
class Mod
{
    long long value;
    void set_value(const long long x)
    {
        this->value = x % mod;
    }

public:
    Mod()
    {
        set_value(0ll);
    }

    template <typename T>
    Mod(T x = 0)
    {
        set_value((long long)x);
    }

    friend istream &operator>>(istream &is, Mod &x)
    {
        long long tmp;
        is >> tmp;
        x.set_value(tmp);
        return is;
    }

    friend ostream &operator<<(ostream &os, const Mod &x)
    {
        os << x.value;
        return os;
    }

    operator long long() const
    {
        return this->value;
    }

    template <typename T>
    bool operator<(const T x)
    {
        return this->value < (long long)x;
    }

    template <typename T>
    bool operator<=(const T x)
    {
        return this->value <= (long long)x;
    }

    template <typename T>
    bool operator>(const T x)
    {
        return this->value > (long long)x;
    }

    template <typename T>
    bool operator>=(const T x)
    {
        return this->value >= (long long)x;
    }

    template <typename T>
    bool operator==(const T x)
    {
        return this->value == (long long)x;
    }

    template <typename T>
    Mod &operator=(const T x)
    {
        set_value((long long)x);
        return *this;
    }

    template <typename T>
    Mod &operator&=(const T x)
    {
        set_value(this->value & (long long)x);
        return *this;
    }

    template <typename T>
    Mod &operator|=(const T x)
    {
        set_value(this->value | (long long)x);
        return *this;
    }

    template <typename T>
    Mod &operator^=(const T x)
    {
        set_value(this->value ^ (long long)x);
        return *this;
    }

    template <typename T>
    Mod &operator<<=(const T x)
    {
        set_value(this->value << (long long)x);
        return *this;
    }

    template <typename T>
    Mod &operator>>=(const T x)
    {
        set_value(this->value >> (long long)x);
        return *this;
    }

    template <typename T>
    Mod &operator+=(const T x)
    {
        set_value(this->value + (long long)x);
        return *this;
    }

    template <typename T>
    Mod &operator-=(const T x)
    {
        set_value(this->value - (long long)x + mod);
        return *this;
    }

    template <typename T>
    Mod &operator*=(const T x)
    {
        set_value(this->value * (long long)x);
        return *this;
    }

    template <typename T>
    Mod &operator/=(const T x)
    {
        long long a = (long long)x;
        long long b = mod;
        long long u = 1;
        long long v = 0;
        while (b)
        {
            long long t = a / b;
            a -= t * b;
            swap(a, b);
            u -= t * v;
            swap(u, v);
        }
        u %= mod;
        if (u < 0)
            u += mod;
        *this *= Mod(u);
        return *this;
    }

    template <typename T>
    Mod operator&(const T x) const
    {
        return Mod(*this) &= x;
    }

    template <typename T>
    Mod operator|(const T x) const
    {
        return Mod(*this) |= x;
    }

    template <typename T>
    Mod operator^(const T x) const
    {
        return Mod(*this) ^= x;
    }

    template <typename T>
    Mod operator<<(const T x) const
    {
        return Mod(*this) <<= x;
    }

    template <typename T>
    Mod operator>>(const T x) const
    {
        return Mod(*this) >>= x;
    }

    template <typename T>
    Mod operator+(const T x) const
    {
        return Mod(*this) += x;
    }

    template <typename T>
    Mod operator-(const T x) const
    {
        return Mod(*this) -= x;
    }

    template <typename T>
    Mod operator*(const T x) const
    {
        return Mod(*this) *= x;
    }

    template <typename T>
    Mod operator/(const T x) const
    {
        return Mod(*this) /= x;
    }

    Mod &operator++()
    {
        *this += 1;
        return *this;
    }

    Mod &operator--()
    {
        this->set_value(--this->value);
        return *this;
    }

    Mod operator++(auto)
    {
        Mod ret(*this);
        ++*this;
        return ret;
    }

    Mod operator--(auto)
    {
        Mod ret(*this);
        --*this;
        return ret;
    }
};

template <typename T>
class Graph
{
    void _dfs_toporogical_sort(vector<bool> &visited, const int n, list<long long> &ret) const
    {
        if (visited[n])
        {
            return;
        }
        visited[n] = true;
        for (auto e : this->edge[n])
        {
            _dfs_toporogical_sort(visited, e.to, ret);
        }
        ret.push_front(n);
    }

    void set_node(const long long N)
    {
        this->node = N + 1;
    }

public:
    struct Edge
    {
        long long to;
        T distance;
        Edge(const long long t, const T d)
        {
            this->to = t;
            this->distance = d;
        }
        bool operator<(const Graph<T>::Edge &e) const
        {
            return this->distance < e.distance;
        }
        bool operator<=(const Graph<T>::Edge &e) const
        {
            return this->distance <= e.distance;
        }
        bool operator>(const Graph<T>::Edge &e) const
        {
            return this->distance > e.distance;
        }
        bool operator>=(const Graph<T>::Edge &e) const
        {
            return this->distance >= e.distance;
        }
        bool operator==(const Graph<T>::Edge &e) const
        {
            return this->distance == e.distance;
        }
    };
    class UnionFind
    {
    public:
        vector<long long> root;

        UnionFind(const long long N)
        {
            this->root = vector<long long>(N + 1, -1);
        }

        long long find_root(const long long A)
        {
            if (this->root[A] < 0)
            {
                return A;
            }
            else
            {
                this->root[A] = find_root(this->root[A]);
            }
            return this->root[A];
        }

        long long size(const long long A)
        {
            return -this->root[find_root(A)];
        }

        bool unite(long long A, long long B)
        {
            A = find_root(A);
            B = find_root(B);
            if (A == B)
            {
                return false;
            }

            if (size(A) < size(B))
            {
                swap(A, B);
            }

            this->root[A] += this->root[B];
            this->root[B] = A;

            return true;
        }

        bool has_same_root(const long long A, const long long B)
        {
            return find_root(A) == find_root(B);
        }
    };
    vector<vector<T>> adjacency_matrix;
    long long node;
    T initial_value;
    vector<vector<Graph<T>::Edge>> edge;

    Graph(const long long N)
    {
        this->set_node(N);
        this->initialize_edge_vector();
    }

    Graph(const long long N, const T init)
    {
        this->set_node(N);
        this->initialize_edge_vector();
        this->set_initial_value(init);
    }

    void set_initial_value(const long long init)
    {
        this->initial_value = init;
    }

    void initialize_adjacency_matrix()
    {
        this->adjacency_matrix = vector<vector<T>>(
            this->node, vector<T>(this->node, this->initial_value));
    }

    void initialize_adjacency_matrix(const T init)
    {
        this->set_initial_value(init);
        this->initialize_adjacency_matrix();
    }

    void initialize_edge_vector()
    {
        this->edge = vector<vector<Graph<T>::Edge>>(this->node);
    }

    void update_adjacency_matrix(const long long from, const long long to, const T distance = 1)
    {
        this->adjacency_matrix[from][to] = distance;
    }

    void add_edge(const long long from, const long long to, const T distance = 1)
    {
        this->edge[from].push_back({to, distance});
    }

    // O(V^3)
    // CAUTION: Use adjacency matrix
    vector<vector<T>> run_floyd_warshall() const
    {
        vector<vector<T>> ret(this->adjacency_matrix);
        for (long long i = 0; i < this->node; i++)
        {
            for (long long j = 0; j < this->node; j++)
            {
                for (long long k = 0; k < this->node; k++)
                {
                    ret[j][k] = min(ret[j][k], ret[j][i] + ret[i][k]);
                }
            }
        }
        return ret;
    }

    // O(E)
    // CAUTION: Non-weighted only
    // CAUTION: Use edge vector
    vector<T> run_bfs(const long long from) const
    {
        vector<T> distance(this->node, this->initial_value);
        vector<bool> visited(this->node, false);
        queue<long long> q;
        q.push(from);
        for (long long i = 0; i < this->node && !q.empty(); i++)
        {
            queue<long long> tmp;
            while (!q.empty())
            {
                if (visited[q.front()])
                {
                    q.pop();
                    continue;
                }
                distance[q.front()] = i;
                visited[q.front()] = true;
                for (Graph<T>::Edge e : this->edge[q.front()])
                {
                    if (visited[e.to])
                    {
                        continue;
                    }
                    tmp.push(e.to);
                }
                q.pop();
            }
            q = tmp;
        }
        return distance;
    }

    // O(VE)
    // CAUTION: Use edge vector
    vector<T> run_bellman_ford(const long long from) const
    {
        vector<T> distance(this->node, this->initial_value);
        distance[from] = 0;

        for (long long i = 0; i < this->node - 1; i++)
        {
            for (long long j = 0; j < this->node; j++)
            {
                for (Graph<T>::Edge e : this->edge[j])
                {
                    if (distance[e.to] > distance[j] + e.distance)
                    {
                        distance[e.to] = distance[j] + e.distance;
                    }
                }
            }
        }
        return distance;
    }

    // O(E + VlogV)
    // CAUTION: Use edge vector
    // CAUTION: Node-indices must be [1, N]
    vector<T> run_dijkstra(const long long from) const
    {
        vector<T> distance(this->node, this->initial_value);
        priority_queue<Graph<T>::Edge, vector<Graph<T>::Edge>, greater<Graph<T>::Edge>> queue;
        queue.push(Graph<T>::Edge(from, 0));
        for (long long i = 1; i < this->node && !queue.empty(); i++)
        {
            T d = queue.top().distance;
            long long to = queue.top().to;
            queue.pop();
            if (distance[to] == this->initial_value)
            {
                distance[to] = d;
                for (Graph<T>::Edge e : this->edge[to])
                {
                    if (distance[e.to] == this->initial_value)
                    {
                        queue.push({e.to, e.distance + d});
                    }
                }
            }
            else
            {
                i--;
            }
        }
        return distance;
    }

    // O(ElogV)
    // CAUTION: Use edge vector
    // CAUTION: Node-indices must be [1, N]
    T run_prim() const
    {
        vector<bool> is_visited(this->node, false);
        T cost = 0;
        priority_queue<Graph<T>::Edge, vector<Graph<T>::Edge>, greater<Graph<T>::Edge>> queue;
        queue.push(Graph<T>::Edge(1, 0));
        for (long long i = 1; i < this->node && !queue.empty(); i++)
        {
            T distance = queue.top().distance;
            long long to = queue.top().to;
            queue.pop();
            if (is_visited[to])
            {
                i--;
            }
            else
            {
                cost += distance;
                is_visited[to] = true;
                for (Graph<T>::Edge e : this->edge[to])
                {
                    queue.push({e.to, e.distance});
                }
            }
        }
        return cost;
    }

    // O(ElogV)
    // CAUTION: Use edge vector
    T run_kruskal() const
    {
        T cost = 0;
        vector<pair<Graph<T>::Edge, long long>> edge_from;
        for (long long i = 0; i < this->node; i++)
        {
            for (auto e : this->edge[i])
            {
                edge_from.push_back(make_pair(e, i));
            }
        }
        sort(edge_from.begin(), edge_from.end());

        Graph<T>::UnionFind uf(this->node);
        for (pair<Graph<T>::Edge, long long> e_f : edge_from)
        {
            auto e = e_f.first;
            long long from = e_f.second;
            if (!uf.has_same_root(from, e.to))
            {
                uf.unite(from, e.to);
                cost += e.distance;
            }
        }
        return cost;
    }

    // O(V)
    // CAUTION: Without cycle only
    // CAUTION: Use edge vector
    vector<long long> run_toporogical_sort() const
    {
        list<long long> ret_list;
        vector<bool> visited(this->node, false);
        for (long long i = 0; i < this->node; i++)
        {
            _dfs_toporogical_sort(visited, i, ret_list);
        }

        vector<long long> ret(ret_list.begin(), ret_list.end());
        return ret;
    }
};

template <long long mod>
pair<int, Mod<mod>> forward1(
    const Graph<int> &g,
    vector<pair<int, Mod<mod>>> &dp,
    const Factrial<Mod<mod>> &factrial,
    const int from,
    const int to)
{
    if (dp[to].first != 0)
    {
        return dp[to];
    }

    dp[to].first++;
    for (auto e : g.edge[to])
    {
        if (e.to == from)
        {
            continue;
        }
        dp[to] = add(dp[to], forward1(g, dp, factrial, to, e.to), factrial);
    }
    return dp[to];
}

template <long long mod>
pair<int, Mod<mod>> forward2(
    const Graph<int> &g,
    const vector<pair<int, Mod<mod>>> &dp,
    vector<pair<int, Mod<mod>>> &ans,
    const Factrial<Mod<mod>> &factrial,
    const int from,
    const int to)
{
    if (ans[from].first == 0)
    {
        ans[to] = dp[to];
    }
    else
    {
        ans[to] = ans[from];
        ans[to] = remove(ans[to], dp[to], factrial);
        ans[to] = add(dp[to], ans[to], factrial);
    }
    for (auto e : g.edge[to])
    {
        if (e.to == from)
        {
            continue;
        }
        forward2(g, dp, ans, factrial, to, e.to);
    }
    return ans[to];
}

template <long long mod>
pair<int, Mod<mod>> add(
    const pair<int, Mod<mod>> a,
    const pair<int, Mod<mod>> b,
    const Factrial<Mod<mod>> &factrial)
{
    pair<int, Mod<mod>> ret = a;
    ret.second *= factrial.get_fact(ret.first + b.first - 1);
    ret.second *= factrial.get_ifact(ret.first - 1);
    ret.first += b.first;
    ret.second *= b.second;
    ret.second *= factrial.get_ifact(b.first);
    return ret;
}

template <long long mod>
pair<int, Mod<mod>> remove(
    const pair<int, Mod<mod>> a,
    const pair<int, Mod<mod>> b,
    const Factrial<Mod<mod>> &factrial)
{
    pair<int, Mod<mod>> ret = a;
    ret.second *= factrial.get_fact(b.first);
    ret.second /= b.second;
    ret.second *= factrial.get_ifact(ret.first - 1);
    ret.second *= factrial.get_fact(ret.first - b.first - 1);
    ret.first -= b.first;
    return ret;
}

int main()
{
    constexpr long long MOD = 1'000'000'007;
    int N;
    cin >> N;

    Graph<int> g(N);
    for (int i = 0; i < N - 1; i++)
    {
        int a, b;
        cin >> a >> b;
        g.add_edge(a, b);
        g.add_edge(b, a);
    }

    Factrial<Mod<MOD>> factrial(g.node);
    vector<pair<int, Mod<MOD>>> dp(g.node, {0, 1});
    vector<pair<int, Mod<MOD>>> ans(g.node, {0, 1});
    forward1(g, dp, factrial, 0, 1);
    forward2(g, dp, ans, factrial, 0, 1);
    for (int i = 1; i <= N; i++)
    {
        cout << ans[i].second << endl;
    }
}


Measured memory_bytes: 27008