#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
typedef pair<LL, LL> PII;

// chmax, chmin
template <class T>
inline bool chmax(T &a, T b)
{
  if (a < b)
  {
    a = b;
    return 1;
  }
  return 0;
}
template <class T>
inline bool chmin(T &a, T b)
{
  if (a > b)
  {
    a = b;
    return 1;
  }
  return 0;
}

template <typename T>
function<T(T, T)> op_max = [](T a, T b) -> T { return max(a, b); };
template <typename T>
function<T(T, T)> op_min = [](T a, T b) -> T { return min(a, b); };

template <typename T>
function<T(T, T)> op_sum = [](T a, T b) -> T { return a + b; };

namespace detail
{
  template <typename T, std::size_t NDIMS>
  struct vector_builder
  {
    using type = std::vector<typename vector_builder<T, NDIMS - 1>::type>;

    static type make(std::vector<std::size_t> dims, const T &v = {})
    {
      const auto vec = std::vector<T>(dims.empty() ? 0 : dims.back(), v);
      if (!dims.empty())
        dims.pop_back();
      return vector_builder<std::vector<T>, NDIMS - 1>::make(dims, vec);
    }
  };

  template <typename T>
  struct vector_builder<T, 1>
  {
    using type = std::vector<T>;

    static type make(std::vector<std::size_t> dims, const T &v = {})
    {
      return type(dims.empty() ? 0 : dims.back(), v);
    }
  };
} // namespace detail

template <typename T, typename... SIZE_T>
auto exvector(const T &v, SIZE_T... dims)
{
  static_assert(sizeof...(dims) != 0, "invalid dimension");
  std::vector<std::size_t> vec_dims{dims...};
  return detail::vector_builder<T, sizeof...(dims)>::make(vec_dims, v);
}

using namespace std;
//********************  dumps ************************//

template <typename T>
void dump(const T &data, vector<int> &iter)
{
  cout << data << " ";
}
template <typename T>
void dump(const vector<T> &data, vector<int> &iter)
{
  for (auto elem : data)
    dump(elem, iter);
  cout << endl;
}

template <typename T>
void dump(const vector<vector<T>> &data, vector<int> &iter)
{
  for (auto elem : iter)
  {
    cout << "[" << elem << "]";
  }
  cout << endl;
  for (int i = 0; i < data.size(); i++)
  {
    iter.push_back(i);
    dump(data[i], iter);
    iter.pop_back();
  }
  cout << endl;
}

template <typename T>
void dump(const vector<T> &data, int dummy)
{
  for (int i = 0; i < data.size(); i++)
  {
    cout << "[" << i << "] " << data[i] << endl;
  }
}
template <typename T>
void dump(const T &data)
{ // T : data, U = base type val.
  vector<int> iter;
  dump(data, iter);
}
///////////////////////////////////////////////

const long long MOD = 1000000007;

template <typename TE>
class Edge
{
public:
  int to;
  TE field;
  Edge() {}
  Edge(int t, TE f) : to(t), field(f) {}
};

template <typename TV, typename TE>
class Vertex
{
public:
  int id;
  int depth;
  TV field;
  Edge<TE> parent;
  vector<Edge<TE>> child;
  vector<Edge<TE>> es;
  Vertex() {}
  Vertex(int in) : id(in) {}
};

template <typename TV, typename TE>
class Graph
{
public:
  int root;
  int N;
  vector<Vertex<TV, TE>> vs;
  // vector<vector<Edge>> es;
  Graph(int n) : N(n)
  {
    for (int i = 0; i < n; i++)
    {
      vs.push_back(Vertex<TV, TE>(i));
    }
    root = -1;
  }
  // 0-indexed
  void add_edge(int v, int u, TE e, bool directed = false)
  {
    vs[v].es.push_back(Edge<TE>(u, e));
    if (!directed)
    {
      vs[u].es.push_back(Edge<TE>(v, e));
    }
  }

  void build_tree(
      int root, function<void(Vertex<TV, TE> &, Vertex<TV, TE> &)> func =
                    [](Vertex<TV, TE> &parent, Vertex<TV, TE> &child) {
                      if (parent.id == -1)
                      {
                        child.depth = 0;
                        return;
                      }
                      child.depth = parent.depth + 1;
                    })
  {
    Vertex<TV, TE> dummy(-1);
    this->root = root;
    func(dummy, vs[root]);
    vector<int> used(N);
    stack<int> sta;
    sta.push(root);
    used[root] = true;
    while (!sta.empty())
    {
      int v = sta.top();
      sta.pop();
      for (auto e : vs[v].es)
      {
        int u = e.to;
        if (used[u])
          continue;
        used[u] = true;
        vs[u].parent = Edge<TE>(v, e.field);
        vs[v].child.push_back(Edge<TE>(u, e.field));
        func(vs[v], vs[u]);
        sta.push(u);
      }
    }
  }

  /*
  葉からの順番を取得。
  */
  vector<int> get_order()
  {
    assert(root != -1);
    vector<int> result;
    stack<int> sta;
    sta.push(root);
    while (!sta.empty())
    {
      int vid = sta.top();
      sta.pop();
      result.push_back(vid);
      for (auto eu : vs[vid].child)
      {
        sta.push(eu.to);
      }
    }
    reverse(result.begin(), result.end());
    return result;
  }

  /*
    update : (T parent, vector<T> child, Vertex parent) -> void
  */

  template <typename T>
  vector<T> update_leaf_root(
      function<void(T &, vector<T *>, Vertex<TV, TE> &)> update)
  {
    vector<int> order = get_order();
    vector<T> table;
    table.resize(N);
    for (auto vid : order)
    {
      vector<T *> childs;
      for (auto eu : vs[vid].child)
      {
        int uid = eu.to;
        childs.push_back(*table[uid]);
      }
      update(table[vid], childs, vs[vid]);
    }
    return table;
  }

  /*
  @brief 全方位木DPができるライブラリ
  @detail クラスTで一般化されている。
  このTは有向辺に対応するDPテーブルである。
  要件 : Tどうしは二項演算が可能で、これらは可換で結合法則がある

  @param[in] init 頂点vで初期化するときのTの値
  @param[in] oper 頂点に入ってくる辺のDPテーブル同士の二項演算
  二項演算されたものどうしでも定義されておく必要がある。
  @param[in] finalize 頂点vから辺eを通って出ていくときに行う演算
  @param[out] result 各頂点vに入ってくる辺に蓄えられているDPテーブルを出力する。
  */
  template <typename T>
  vector<vector<T>> update_all(
      function<void(Vertex<TV, TE> &, T &)> init, function<T(T, T)> oper,
      function<void(Vertex<TV, TE> &, Edge<TE> &, T &)> finalize)
  {
    build_tree(0);
    assert(root != -1);
    vector<vector<T>> result;
    result.resize(N);
    vector<int> order = get_order();
    vector<vector<T>> up(N);
    vector<T> down(N);
    for (auto vid : order)
    {
      T latest;
      up[vid].push_back(latest);
      init(vs[vid], up[vid].back());
      for (auto eu : vs[vid].child)
      {
        int uid = eu.to;
        result[vid].push_back(up[uid].back());
        up[vid].push_back(oper(up[vid].back(), up[uid].back()));
      }
      T last = up[vid].back();
      finalize(vs[vid], vs[vid].parent, last);
      up[vid].push_back(last);
    }
    reverse(order.begin(), order.end());
    for (auto vid : order)
    {
      int m = vs[vid].child.size();
      T tmp;
      init(vs[vid], tmp);
      if (vid != root)
      {
        tmp = oper(tmp, down[vid]);
        result[vid].push_back(down[vid]);
      }
      for (int i = m - 1; i >= 0; i--)
      {
        int uid = vs[vid].child[i].to;
        down[uid] = oper(up[vid][i], tmp);
        finalize(vs[vid], vs[vid].child[i], down[uid]);
        tmp = oper(tmp, up[uid].back());
      }
    }
    return result;
  }

  /*
  // example of update-all-direction.

  struct TV {};
  struct TE {
    int w;
  };


  struct DP {
    LL dist;
    LL flip;
  };
  function<void(Vertex<TV, TE>&, DP&)> dp_init = [](Vertex<TV, TE>& v, DP& dp) {
    dp.dist = 0;
    dp.flip = 0;
  };
  function<DP(DP, DP)> dp_eval = [](DP dp1, DP dp2) {
    DP dp;
    dp.dist = max(dp1.dist, dp2.dist);
    dp.flip = dp1.flip + dp2.flip;
    return dp;
  };
  function<void(Vertex<TV, TE> & v, Edge<TE>&, DP&)> dp_finalize =
      [](Vertex<TV, TE>& v, Edge<TE>& out, DP& dp) {
        dp.dist += out.field.weight;
        if (out.to != out.field.to) dp.flip++;
      };

  int N;
  cin >> N;
  Graph graph(N);
  for(int i=0; i<N-1; i++) {
    int v, u;
    cin >> v >> u;
    TE e;
    graph.add_edge(v, u, e);
  }

  auto results = graph.update_all(dp_init, dp_eval, dp_finalize);
  for (auto vec : results) {
    DP base;
    base.ans = 1;
    for (auto val : vec) base = dp_eval(base, val);
    cout << base.ans << endl;
  }
  */
};

const long long MOD_CONST = 1000000007;
long long mul_mod(long long a, long long b, const long long MOD)
{
  return b ? (mul_mod(a * 2, b / 2, MOD) + (b & 1 ? a : 0)) % MOD : 0;
}

long long bpow_mod(long long a, long long b, const long long MOD)
{
  return (b ? bpow_mod(a * a % MOD, b / 2, MOD) * (b & 1 ? a : 1) : 1) % MOD;
}

long long inv_mod(long long a, const long long MOD)
{
  return bpow_mod(a, MOD - 2, MOD);
}
template <long long param = MOD_CONST, bool fast = false>
class mint
{
private:
  using Z = int;
  using N = unsigned int;
  using ZZ = long long;
  using NN = unsigned long long;
  struct
  {
  } constexpr static exact{};
  // Using Z deliberately to avoid Z -> N promotion.
  template <class Ret = ZZ &>
  static auto modulo() -> std::enable_if_t<(param <= 0), Ret>
  {
    static ZZ mod = 0;
    return mod;
  }
  template <class Ret = const ZZ>
  static auto mod() -> std::enable_if_t<(param <= 0), Ret>
  {
    return modulo();
  }
  template <class Ret = const ZZ>
  static constexpr auto mod() -> std::enable_if_t<(param > 0), Ret>
  {
    return param;
  }

public:
  template <class Arg = ZZ>
  static void set_modulo(const std::enable_if_t<(param <= 0), Arg> mod)
  {
    modulo() = mod;
  }
  long long v;

  constexpr mint() : v(0) {}

  constexpr mint(long long v)
      : v(fast ? (v)
               : (v < 0 ? (v % mod() + mod()) % mod()
                        : (v >= mod() ? v % mod() : v))) {}
  constexpr long long get_mod() { return mod(); }
  long long get_val() { return v; }
  void take_mod() { v %= mod(); }
};
template <long long param, bool fast>
ostream &operator<<(ostream &os, mint<param, fast> &x)
{
  return os << (x.v % x.get_mod() + x.get_mod()) % x.get_mod();
}

template <long long param, bool fast, bool fast2>
bool operator==(mint<param, fast> &a, mint<param, fast2> b)
{
  return a.v == b.v;
}
template <long long param, bool fast, bool fast2>
mint<param, fast> &operator+=(mint<param, fast> &a, mint<param, fast2> b)
{
  return a = a.v + b.v;
}
template <long long param>
mint<param> &operator-=(mint<param> &a, mint<param> b)
{
  return a = a.v - b.v;
}
template <long long param>
mint<param> &operator*=(mint<param> &a, mint<param> b)
{
  return a = a.v * b.v;
}
template <long long param>
mint<param> &operator/=(mint<param> &a, mint<param> b)
{
  return a = a.v * inv_mod(b.v, a.get_mod());
}
template <long long param, bool fast, bool fast2>
mint<param, fast> operator+(mint<param, fast> a, mint<param, fast2> b)
{
  return a += b;
}
template <long long param>
mint<param> operator-(mint<param> a, mint<param> b)
{
  return a -= b;
}
template <long long param>
mint<param> operator*(mint<param> a, mint<param> b)
{
  return a *= b;
}
template <long long param>
mint<param> operator/(mint<param> a, mint<param> b)
{
  return a /= b;
}
template <long long param, bool fast>
mint<param, fast> &operator+=(mint<param, fast> &a, long long b)
{
  return a = a.v + b;
}
template <long long param>
mint<param> &operator-=(mint<param> &a, long long b)
{
  return a = a.v - b;
}
template <long long param>
mint<param> &operator*=(mint<param> &a, long long b)
{
  return a = a.v * b;
}
template <long long param>
mint<param> &operator/=(mint<param> &a, long long b)
{
  return a = a.v * inv_mod(b, a.get_mod());
}
template <long long param, bool fast>
mint<param, fast> operator+(mint<param> a, long long b)
{
  return a += b;
}
template <long long param>
mint<param> operator-(mint<param> a, long long b)
{
  return a -= b;
}
template <long long param>
mint<param> operator*(mint<param> a, long long b)
{
  return a *= b;
}
template <long long param>
mint<param> operator/(mint<param> a, long long b)
{
  return a /= b;
}

template <int size = 400000, long long param = MOD_CONST, bool preserve = false>
class CombinationTool
{
  vector<mint<param>> invs;

public:
  vector<mint<param>> kaijo;
  vector<vector<mint<param>>> table;

  CombinationTool()
  {
    int N = size;
    if (preserve)
    {
      table.resize(N + 5);
      for (int i = 0; i < N + 5; i++)
        table[i].resize(i + 1);
      for (int i = 0; i < N; i++)
      {
        table[i][0] = 1;
        table[i][i] = 1;
      }
      for (int i = 1; i < N + 5; i++)
        for (int j = 1; j < i; j++)
          table[i][j] = table[i - 1][j - 1] + table[i - 1][j];
    }
    else
    {
      kaijo.resize(N + 5);
      invs.resize(N + 5);
      kaijo[0] = 1;
      invs[0] = 1;
      for (int i = 1; i < N + 5; i++)
      {
        kaijo[i] = kaijo[i - 1] * i;
        invs[i] = mint<param>(1) / kaijo[i];
      }
    }
  }

  mint<param> get(int n, int m)
  {
    if (m < 0 || m > n)
      return mint<param>(0);
    if (preserve)
      return table[n][m];
    return kaijo[n] * invs[m] * invs[n - m];
  }
};

void solve(long long N, std::vector<long long> a, std::vector<long long> b)
{
  CombinationTool<> comb;

  struct TV
  {
  };
  struct TE
  {
  };

  struct DP
  {
    LL child;
    mint<> result;
  };

  function<void(Vertex<TV, TE> &, DP &)> dp_init = [](Vertex<TV, TE> &v, DP &dp) {
    dp.child = 0;
    dp.result = 1;
  };
  function<DP(DP, DP)> dp_eval = [&](DP dp1, DP dp2) {
    DP dp;
    dp.child = dp1.child + dp2.child;
    dp.result = dp1.result * dp2.result * comb.get(dp.child, dp1.child);
    //cout << dp.child << " " << dp1.child << endl;

    return dp;
  };
  function<void(Vertex<TV, TE> & v, Edge<TE> &, DP &)> dp_finalize =
      [](Vertex<TV, TE> &v, Edge<TE> &out, DP &dp) {
        dp.child += 1;
      };

  Graph<TV, TE> graph(N);
  for (int i = 0; i < N - 1; i++)
  {
    TE e;
    graph.add_edge(a[i] - 1, b[i] - 1, e);
  }

  auto results = graph.update_all(dp_init, dp_eval, dp_finalize);
  for (auto vec : results)
  {
    DP base;
    base.child = 0;
    base.result = 1;
    for (auto val : vec)
      base = dp_eval(base, val);
    cout << base.result << endl;
  }
}

int main()
{
  cout << setprecision(10);
  long long N;
  scanf("%lld", &N);
  std::vector<long long> a(N - 1);
  std::vector<long long> b(N - 1);
  for (int i = 0; i < N - 1; i++)
  {
    scanf("%lld", &a[i]);
    scanf("%lld", &b[i]);
  }
  solve(N, std::move(a), std::move(b));
  return 0;
}


Measured memory_bytes: 76008