Problem p03991 (C++)

Buggy submission (status: Runtime Error):
#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
#define int long long
#define ll long long
using ull = unsigned long long;
using namespace std;
#define dump(x)                                                                \
  if (dbg) {                                                                   \
    cerr << #x << " = " << (x) << endl;                                        \
  }
#define overload4(_1, _2, _3, _4, name, ...) name
#define FOR1(n) for (ll i = 0; i < (n); ++i)
#define FOR2(i, n) for (ll i = 0; i < (n); ++i)
#define FOR3(i, a, b) for (ll i = (a); i < (b); ++i)
#define FOR4(i, a, b, c) for (ll i = (a); i < (b); i += (c))
#define FOR(...) overload4(__VA_ARGS__, FOR4, FOR3, FOR2, FOR1)(__VA_ARGS__)
#define FORR(i, a, b) for (int i = (a); i <= (b); ++i)
#define bit(n, k) ((n >> k) & 1) /*nのk bit目*/
namespace mydef {
const int INF = 1ll << 60;
const int MOD = 924844033;
template <class T> bool chmin(T &a, const T &b) {
  if (a > b) {
    a = b;
    return 1;
  } else
    return 0;
}
template <class T> bool chmax(T &a, const T &b) {
  if (a < b) {
    a = b;
    return 1;
  } else
    return 0;
}
void Yes(bool flag = true) {
  if (flag)
    cout << "Yes" << endl;
  else
    cout << "No" << endl;
}
void No(bool flag = true) { Yes(!flag); }
void YES(bool flag = true) {
  if (flag)
    cout << "YES" << endl;
  else
    cout << "NO" << endl;
}
void NO(bool flag = true) { YES(!flag); }
template <typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &val) {
  std::fill((T *)array, (T *)(array + N), val);
}
bool dbg = true;
} // namespace mydef
using namespace mydef;
#define pb push_back
#define mp make_pair
#define eb emplace_back
#define lb lower_bound
#define ub upper_bound
#define all(v) (v).begin(), (v).end()
#define SZ(x) ((int)(x).size())
#define vi vector<int>
#define vvi vector<vector<int>>
#define vp vector<pair<int, int>>
#define vvp vector<vector<pair<int, int>>>
#define pi pair<int, int>
// #define P pair<int, int>
// #define V vector<int>
// #define S set<int>
#define asn ans

template <signed mod> struct NumberTheoreticTransform {
private:
  vector<signed> rev, rts; // swap計算用の配列, \omega^iに相当するもの
  signed base, max_base, root;
  inline signed mod_add(signed a, signed b) {
    a += b;
    if (a >= mod)
      a -= mod;
    return a;
  }
  inline signed mod_mul(signed a, signed b) {
    return (1ull * a * b) % (unsigned long long)mod;
  }
  inline signed mod_pow(signed a, signed n) {
    signed ret = 1;
    while (n) {
      if (n & 1)
        ret = mod_mul(ret, a);
      a = mod_mul(a, a);
      n >>= 1;
    }
    return ret;
  }
  inline signed mod_inv(signed a) { return mod_pow(a, mod - 2); }
  //
public:
  NumberTheoreticTransform() : base(1), rev{0, 1}, rts{0, 1} {
    assert(mod >= 3 && mod & 1 == 1);
    signed tmp = mod - 1;
    max_base = 0;
    while (tmp % 2 == 0) {
      tmp >>= 1;
      max_base++;
    }
    root = 2;
    while (mod_pow(root, (mod - 1) >> 1) == 1)
      root++;
    assert(mod_pow(root, mod - 1) == 1);
    root = mod_pow(root, (mod - 1) >> max_base);
  }
  //
private:
  void ensure_base(signed nbase) {
    if (nbase <= base)
      return;
    assert(nbase <= max_base);
    rev.resize(1 << nbase);
    rts.resize(1 << nbase);
    for (signed i = 0; i < (1 << nbase); i++) {
      rev[i] = (rev[i >> 1] >> 1) + ((i & 1) << (nbase - 1));
    }
    while (base < nbase) {
      signed z = mod_pow(root, 1 << (max_base - 1 - base));
      for (signed i = 1 << (base - 1); i < (1 << base); i++) {
        rts[i << 1] = rts[i];
        rts[(i << 1) + 1] = mod_mul(rts[i], z);
      }
      base++;
    }
  }
  void ntt(vector<signed> &a) {
    const signed n = (signed)a.size();
    assert((n & (n - 1)) == 0);
    signed zeros = __builtin_ctz(n);
    ensure_base(zeros);
    signed shift = base - zeros;
    for (signed i = 0; i < n; i++) {
      if (i < (rev[i] >> shift))
        swap(a[i], a[rev[i] >> shift]);
    }
    for (signed k = 1; k < n; k <<= 1) {
      for (signed i = 0; i < n; i += 2 * k) {
        for (signed j = 0; j < k; j++) {
          signed z = mod_mul(a[i + j + k], rts[j + k]);
          a[i + j + k] = mod_add(a[i + j], mod - z);
          a[i + j] = mod_add(a[i + j], z);
        }
      }
    }
  }
  //
public:
  vector<signed> multiply(vector<signed> a, vector<signed> b) {
    if (a.empty() || b.empty())
      return {};
    bool eq = (a == b);
    signed need = a.size() + b.size() - 1;
    signed nbase = 1;
    while ((1 << nbase) < need)
      nbase++;
    ensure_base(nbase);
    signed sz = 1 << nbase;
    a.resize(sz, 0);
    b.resize(sz, 0);
    ntt(a);
    if (eq)
      b = a;
    else
      ntt(b);
    signed inv_sz = mod_inv(sz);
    for (signed i = 0; i < sz; i++) {
      a[i] = mod_mul(a[i], mod_mul(b[i], inv_sz));
    }
    reverse(a.begin() + 1, a.end());
    ntt(a);
    a.resize(need);
    return a;
  }
  vector<long long> multiply(vector<long long> a, vector<long long> b) {
    vector<signed> A(a.size()), B(b.size());
    for (signed i = 0; i < a.size(); i++) {
      A[i] = a[i];
    }
    for (signed i = 0; i < b.size(); i++) {
      B[i] = b[i];
    }
    A = multiply(A, B);
    a.resize(A.size());
    for (signed i = 0; i < A.size(); i++)
      a[i] = A[i];
    return a;
  }
};

template <uint MD> struct ModInt {
  using M = ModInt;
  const static M G;
  uint v;
  ModInt(ll _v = 0) { set_v(_v % MD + MD); }
  M &set_v(uint _v) {
    v = (_v < MD) ? _v : _v - MD;
    return *this;
  }
  explicit operator bool() const { return v != 0; }
  M operator-() const { return M() - *this; }
  M operator+(const M &r) const { return M().set_v(v + r.v); }
  M operator-(const M &r) const { return M().set_v(v + MD - r.v); }
  M operator*(const M &r) const { return M().set_v(ull(v) * r.v % MD); }
  M operator/(const M &r) const { return *this * r.inv(); }
  M &operator+=(const M &r) { return *this = *this + r; }
  M &operator-=(const M &r) { return *this = *this - r; }
  M &operator*=(const M &r) { return *this = *this * r; }
  M &operator/=(const M &r) { return *this = *this / r; }
  bool operator==(const M &r) const { return v == r.v; }
  M pow(ll n) const {
    M x = *this, r = 1;
    while (n) {
      if (n & 1)
        r *= x;
      x *= x;
      n >>= 1;
    }
    return r;
  }
  M inv() const { return pow(MD - 2); }
  /*
  M inv() const {
      long long b = MD, u = 1, v = 0;
      long long a = (*this).v;
      while (b) {
          long long t = a / b;
          a -= t * b;
          swap(a, b);
          u -= t * v;
          swap(u, v);
      }
      u %= MD;
      if (u < 0)
          u += MD;
      return M{u};
  }
  */
  friend ostream &operator<<(ostream &os, const M &r) { return os << r.v; }
  friend istream &operator>>(istream &is, M &r) { return is >> r.v; }
};

using Mint = ModInt<MOD>;
const int MN = 2000010;
Mint fact[MN], iFac[MN];

void first() {
  fact[0] = Mint(1);
  for (int i = 1; i < MN; i++)
    fact[i] = fact[i - 1] * Mint(i);
  iFac[MN - 1] = fact[MN - 1].inv();
  for (int i = MN - 1; i >= 1; i--) {
    iFac[i - 1] = iFac[i] * Mint(i);
  }
  assert(fact[2345] * iFac[2345] == Mint(1));
}
Mint C(int n, int k) {
  if (n < k || k < 0)
    return Mint(0);
  return fact[n] * iFac[k] * iFac[n - k];
}

template <typename T> struct edge {
  int to, id;
  T cost;
  edge(int to) : to(to), id(-1), cost(1) {}
  edge(int to, T cost) : to(to), id(-1), cost(cost) {}
  edge(int to, T cost, int id) : to(to), id(id), cost(cost) {}
  operator int() const { return to; }
  /*
      edge& operator=(const int& x) {
          to = x;
          return *this;
      }
      */
};
template <typename T> class Graph : public vector<vector<edge<T>>> {
  //--------Basic--------
private:
  using Edge = edge<T>;
  int M; // M:辺の数
  bool undirected = false;
  bool directed = false;
  bool unweighted = false;
  bool weighted = false;
  bool tree = false;
  //
public:
  //
public:
  Graph() = default;
  // unweighted
  void add_edge_undirected(int u, int v, int id = -1) {
    assert(!directed);
    assert(!weighted);
    undirected = true;
    unweighted = true;
    (*this)[u].emplace_back(Edge{v, 1, id});
    (*this)[v].emplace_back(Edge{u, 1, id});
  }
  void build_undirected(int m) {
    assert(!(*this).empty());
    assert(!directed);
    assert(!weighted);
    undirected = true;
    unweighted = true;
    M = m;
    for (int i = 0; i < m; i++) {
      int u, v;
      cin >> u >> v;
      u--;
      v--;
      (*this)[u].emplace_back(Edge{v, 1, i});
      (*this)[v].emplace_back(Edge{u, 1, i});
    }
  }
  void build_undirected(int n, int m) {
    (*this).resize(n);
    build_undirected(m);
  }
  void add_edge_directed(int u, int v, int id = -1) {
    assert(!undirected);
    assert(!weighted);
    directed = true;
    unweighted = true;
    (*this)[u].emplace_back(Edge{v, 1, id});
  }
  void build_directed(int m) {
    assert(!(*this).empty());
    assert(!undirected);
    assert(!weighted);
    directed = true;
    unweighted = true;
    M = m;
    for (int i = 0; i < m; i++) {
      int u, v;
      cin >> u >> v;
      u--;
      v--;
      (*this)[u].emplace_back(Edge{v, 1, i});
    }
  }
  void build_directed(int n, int m) {
    (*this).resize(n);
    build_undirected(m);
  }
  // weighed
  void add_edge_undirected_weighed(int u, int v, T cost, int id = -1) {
    assert(!directed);
    assert(!unweighted);
    undirected = true;
    weighted = true;
    (*this)[u].emplace_back(Edge{v, cost, id});
    (*this)[v].emplace_back(Edge{u, cost, id});
  }
  void build_undirected_weighted(int m) {
    assert(!(*this).empty());
    assert(!directed);
    assert(!unweighted);
    undirected = true;
    weighted = true;
    M = m;
    for (int i = 0; i < m; i++) {
      int u, v;
      T cost;
      cin >> u >> v >> cost;
      u--;
      v--;
      (*this)[u].emplace_back(Edge{v, cost, i});
      (*this)[v].emplace_back(Edge{u, cost, i});
    }
  }
  void build_undirected_weighted(int n, int m) {
    (*this).resize(n);
    build_undirected(m);
  }
  void add_edge_directed_weighted(int u, int v, T cost, int id = -1) {
    assert(!undirected);
    assert(!unweighted);
    directed = true;
    weighted = true;
    (*this)[u].emplace_back(Edge{v, cost, id});
  }
  void build_directed_weighted(int m) {
    assert(!(*this).empty());
    assert(!undirected);
    assert(!unweighted);
    directed = true;
    weighted = true;
    M = m;
    for (int i = 0; i < m; i++) {
      int u, v;
      T cost;
      cin >> u >> v >> cost;
      u--;
      v--;
      (*this)[u].emplace_back(Edge{v, cost, i});
    }
  }
  void build_directed_weighted(int n, int m) {
    (*this).resize(n);
    build_undirected(m);
  }
  // tree
  void istree() { tree = true; }
  void build_tree(int n) {
    istree();
    build_undirected(n, n - 1);
  }
  void build_tree_weighted(int n) {
    istree();
    build_undirected_weighted(n, n - 1);
  }
  // print state
  void state() {
    cerr << endl
         << "Print State" << endl
         << "Edge :" << endl
         << "    Directed   : " << (directed ? "Yes" : "No") << endl
         << "    Undirected : " << (undirected ? "Yes" : "No") << endl
         << "    Weighted   : " << (weighted ? "Yes" : "No") << endl
         << "    Unweighted : " << (unweighted ? "Yes" : "No") << endl
         << "    Tree       : " << (tree ? "Yes" : "No") << endl
         << "Usable Functions : Graph" << endl
         << "    StronglyConnectedComponent(unverified): "
         << (StronglyConnectedComponent_ready ? "Yes" : "No") << endl
         << "Usable Funcitons : Tree" << endl
         << "    ReRooting(verified) : Yes" << endl;
  }
  //
  //
  //
  //--------StronglyConnectedComponent--------
  // Unverified
public:
  vector<vector<int>> SCC_R, SCC_T;
  //
private:
  bool StronglyConnectedComponent_ready = false;
  vector<int> SCC_cmp, SCC_ord;
  vector<bool> SCC_used;
  //
public:
  int SCC_build() {
    cerr << "Please Verify" << endl;
    assert(!undirected);
    assert(directed);
    int N = (*this).size();
    SCC_R.resize(N);
    for (int i = 0; i < N; i++) {
      for (int &x : (*this)[i]) {
        SCC_R[x].emplace_back(i);
      }
    }
    SCC_cmp.resize(N);
    fill(SCC_cmp.begin(), SCC_cmp.end(), -1);
    SCC_used.resize(N);
    fill(SCC_used.begin(), SCC_used.end(), false);
    StronglyConnectedComponent_ready = true;
    return build_StronglyConnectedComponent_init();
  }
  int SCC(int k) {
    assert(StronglyConnectedComponent_ready);
    return SCC_cmp[k];
  }
  //
private:
  void dfs(int now) {
    if (SCC_used[now])
      return;
    SCC_used[now] = true;
    for (auto nxt : (*this)[now])
      dfs(nxt);
    SCC_ord.emplace_back(now);
  }
  void rdfs(int now, int count) {
    if (SCC_cmp[now] != -1)
      return;
    SCC_cmp[now] = count;
    for (auto to : SCC_R[now])
      rdfs(to, count);
  }
  int build_StronglyConnectedComponent_init() {
    int n = (int)(*this).size();
    for (int i = 0; i < n; i++)
      dfs(i);
    reverse(SCC_ord.begin(), SCC_ord.end());
    int group = 0;
    for (auto &i : SCC_ord) {
      if (SCC_cmp[i] == -1) {
        rdfs(i, group);
        group++;
      }
    }
    SCC_T.resize(group);
    for (int i = 0; i < n; i++) {
      for (auto &to : (*this)[i]) {
        int s = SCC_cmp[i], t = SCC_cmp[to];
        if (s != t)
          SCC_T[s].emplace_back(t);
      }
    }
    return group;
  }
  //
  //
  //
  //--------TopologicalSort--------
  // 未実装
  //
  //
  //
  //--------Tree--------
  //
  //
  //--------ReRooting--------
  // unverified
private:
  template <typename sum_t>
  void
  ReRooting_dfs_sub(int idx, int par, const function<sum_t(sum_t, sum_t)> &f,
                    const function<sum_t(sum_t, Edge)> &gg, const sum_t &ident,
                    vector<sum_t> &subdp, vector<sum_t> &dp,
                    vector<vector<sum_t>> &g_dp, vector<vector<sum_t>> &g_ndp,
                    vector<vector<sum_t>> &memo, vector<vector<bool>> &seen) {
    for (int i = 0; i < (int)((*this)[idx].size()); i++) {
      auto &e = (*this)[idx][i];
      if (e.to == par)
        continue;
      ReRooting_dfs_sub<sum_t>(e.to, idx, f, gg, ident, subdp, dp, g_dp, g_ndp,
                               memo, seen);
      if (!seen[idx][i]) {
        memo[idx][i] = gg(subdp[e.to], e);
        seen[idx][i] = true;
      }
      subdp[idx] = f(subdp[idx], memo[idx][i]);
    }
  }
  template <typename sum_t>
  void
  ReRooting_dfs_all(int idx, int par, const sum_t &top,
                    const function<sum_t(sum_t, sum_t)> &f,
                    const function<sum_t(sum_t, Edge)> &gg, const sum_t &ident,
                    vector<sum_t> &subdp, vector<sum_t> &dp,
                    vector<vector<sum_t>> &g_dp, vector<vector<sum_t>> &g_ndp,
                    vector<vector<sum_t>> &memo, vector<vector<bool>> &seen) {
    sum_t buff{ident};
    for (int i = 0; i < (int)((*this)[idx].size()); i++) {
      auto &e = (*this)[idx][i];
      g_ndp[idx][i] = buff;
      if (!seen[idx][i]) {
        memo[idx][i] = gg(par == e.to ? top : subdp[e.to], e);
        seen[idx][i] = true;
      }
      g_dp[idx][i] = memo[idx][i];
      buff = f(buff, g_dp[idx][i]);
    }
    dp[idx] = buff;
    buff = ident;
    for (int i = (*this)[idx].size() - 1; i >= 0; i--) {
      auto &e = (*this)[idx][i];
      if (e.to != par)
        ReRooting_dfs_all<sum_t>(e.to, idx, f(g_ndp[idx][i], buff), f, gg,
                                 ident, subdp, dp, g_dp, g_ndp, memo, seen);
      g_ndp[idx][i] = f(g_ndp[idx][i], buff);
      buff = f(buff, g_dp[idx][i]);
    }
  }
  //
public:
  template <typename sum_t>
  pair<vector<sum_t>, vector<vector<sum_t>>>
  Tbuild_ReRooting(const function<sum_t(sum_t, sum_t)> f,
                   const function<sum_t(sum_t, Edge)> gg, sum_t ident) {
    assert(tree);
    int N = (*this).size();
    vector<sum_t> subdp(N, ident), dp(N, ident);
    vector<vector<sum_t>> g_dp(N), g_ndp(N), memo(N);
    vector<vector<bool>> seen(N);
    for (int i = 0; i < N; i++) {
      int S = (*this)[i].size();
      g_dp[i].resize(S, ident);
      g_ndp[i].resize(S, ident);
      memo[i].resize(S);
      seen[i].resize(S, false);
    }
    stack<int> stk;
    stk.push(0);
    vector<int> par(N), ord(N);
    int index = 0;
    par[0] = -1;
    while (!stk.empty()) {
      int node = stk.top();
      stk.pop();
      ord[index++] = node;
      for (auto &e : (*this)[node]) {
        if (e.to == par[node])
          continue;
        stk.push(e.to);
        par[e.to] = node;
      }
    }
    for (int k = ord.size() - 1; k >= 0; k--) {
      int idx = ord[k];
      for (int i = 0; i < (int)((*this)[idx].size()); i++) {
        auto &e = (*this)[idx][i];
        if (e.to == par[idx])
          continue;
        if (!seen[idx][i]) {
          memo[idx][i] = gg(subdp[e.to], e);
          seen[idx][i] = true;
        }
        subdp[idx] = f(subdp[idx], memo[idx][i]);
      }
    }
    vector<sum_t> top(N, ident);
    for (int k = 0; k < (int)(ord.size()); k++) {
      int idx = ord[k];
      sum_t buff{ident};
      for (int i = 0; i < (int)((*this)[idx].size()); i++) {
        auto &e = (*this)[idx][i];
        g_ndp[idx][i] = buff;
        if (!seen[idx][i]) {
          memo[idx][i] = gg(par[idx] == e.to ? top[idx] : subdp[e.to], e);
          seen[idx][i] = true;
        }
        g_dp[idx][i] = memo[idx][i];
        buff = f(buff, g_dp[idx][i]);
      }
      dp[idx] = buff;
      buff = ident;
      for (int i = (*this)[idx].size() - 1; i >= 0; i--) {
        auto &e = (*this)[idx][i];
        if (e.to != par[idx])
          top[e.to] = f(g_ndp[idx][i], buff);
        g_ndp[idx][i] = f(g_ndp[idx][i], buff);
        buff = f(buff, g_dp[idx][i]);
      }
    }
    return make_pair(dp, memo);
  }
};
// グローバルでの使用のみ想定

template <typename sum_t, typename key_t> struct ReRooting {
  struct Edge {
    int to;
    key_t data;
    sum_t dp, ndp;
  };

  using F = function<sum_t(sum_t, sum_t)>;
  using G = function<sum_t(sum_t, key_t)>;

  vector<vector<Edge>> g;
  vector<sum_t> subdp, dp;
  const sum_t ident;
  const F f;
  const G gg;

  ReRooting(int V, const F f, const G g, const sum_t &ident)
      : g(V), f(f), gg(g), ident(ident), subdp(V, ident), dp(V, ident) {}

  void add_edge(int u, int v, const key_t &d) {
    g[u].emplace_back((Edge){v, d, ident, ident});
    g[v].emplace_back((Edge){u, d, ident, ident});
  }

  void add_edge_bi(int u, int v, const key_t &d, const key_t &e) {
    g[u].emplace_back((Edge){v, d, ident, ident});
    g[v].emplace_back((Edge){u, e, ident, ident});
  }

  void dfs_sub(int idx, int par) {
    for (auto &e : g[idx]) {
      if (e.to == par)
        continue;
      dfs_sub(e.to, idx);
      subdp[idx] = f(subdp[idx], gg(subdp[e.to], e.data));
    }
  }

  void dfs_all(int idx, int par, const sum_t &top) {
    sum_t buff{ident};
    for (int i = 0; i < (int)g[idx].size(); i++) {
      auto &e = g[idx][i];
      e.ndp = buff;
      e.dp = gg(par == e.to ? top : subdp[e.to], e.data);
      buff = f(buff, e.dp);
    }
    dp[idx] = buff;
    buff = ident;
    for (int i = (int)g[idx].size() - 1; i >= 0; i--) {
      auto &e = g[idx][i];
      if (e.to != par)
        dfs_all(e.to, idx, f(e.ndp, buff));
      e.ndp = f(e.ndp, buff);
      buff = f(buff, e.dp);
    }
  }

  vector<sum_t> build() {
    dfs_sub(0, -1);
    dfs_all(0, -1, ident);
    return dp;
  }
};
// https://ei1333.hateblo.jp/entry/2018/12/21/004022

Graph<int> G;

int N, a[202020], b[202020];
int memo[202020] = {};
int memo2[202020] = {};

void solve() {
  vector<Mint> cnt(N, Mint{0});
  ReRooting<int, int> g(
      N, [](int a, int b) { return a + b; },
      [&](int x, int i) {
        memo[i] = x + 1;
        return x + 1;
      },
      0);
  for (int i = 0; i < N - 1; i++) {
    g.add_edge(a[i], b[i], i);
  }
  g.build();

  /*
  G.istree();
  G.Tbuild_ReRooting<int>(
      [](int a, int b) { return a + b; },
      [&](int x, edge<int> e) {
          int i = e.id;
          memo2[i] = x + 1;
          return x + 1;
      },
      0);
  */

  for (int i = 0; i < N - 1; i++) {
    if (memo[i] == 0)
      continue;
    cnt[memo[i]] += 1;
    cnt[N - memo[i]] += 1;
  }

  first();
  vector<int> A(N, 0), B(N + 1, 0);
  for (int i = 0; i < N; i++) {
    A[i] = (fact[i] * cnt[i]).v;
  }
  for (int i = 0; i <= N; i++) {
    B[i] = iFac[N - i].v;
  }

  NumberTheoreticTransform<MOD> ntt;
  auto ans = ntt.multiply(A, B);

  for (int K = 1; K <= N; K++) {
    cout << (int)(C(N, K) * N - iFac[K] * ans[N + K]).v << endl;
  }
}

signed main() {

  cin >> N;
  G.resize(N);
  for (int i = 0; i < N - 1; i++) {
    cin >> a[i] >> b[i];
    a[i]--;
    b[i]--;
    G.add_edge_undirected(a[i], b[i], i);
  }
  // G.build_tree(N);

  solve();
  return 0;
}


Fixed submission:
// #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
#define int long long
#define ll long long
using ull = unsigned long long;
using namespace std;
#define dump(x)                                                                \
  if (dbg) {                                                                   \
    cerr << #x << " = " << (x) << endl;                                        \
  }
#define overload4(_1, _2, _3, _4, name, ...) name
#define FOR1(n) for (ll i = 0; i < (n); ++i)
#define FOR2(i, n) for (ll i = 0; i < (n); ++i)
#define FOR3(i, a, b) for (ll i = (a); i < (b); ++i)
#define FOR4(i, a, b, c) for (ll i = (a); i < (b); i += (c))
#define FOR(...) overload4(__VA_ARGS__, FOR4, FOR3, FOR2, FOR1)(__VA_ARGS__)
#define FORR(i, a, b) for (int i = (a); i <= (b); ++i)
#define bit(n, k) ((n >> k) & 1) /*nのk bit目*/
namespace mydef {
const int INF = 1ll << 60;
const int MOD = 924844033;
template <class T> bool chmin(T &a, const T &b) {
  if (a > b) {
    a = b;
    return 1;
  } else
    return 0;
}
template <class T> bool chmax(T &a, const T &b) {
  if (a < b) {
    a = b;
    return 1;
  } else
    return 0;
}
void Yes(bool flag = true) {
  if (flag)
    cout << "Yes" << endl;
  else
    cout << "No" << endl;
}
void No(bool flag = true) { Yes(!flag); }
void YES(bool flag = true) {
  if (flag)
    cout << "YES" << endl;
  else
    cout << "NO" << endl;
}
void NO(bool flag = true) { YES(!flag); }
template <typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &val) {
  std::fill((T *)array, (T *)(array + N), val);
}
bool dbg = true;
} // namespace mydef
using namespace mydef;
#define pb push_back
#define mp make_pair
#define eb emplace_back
#define lb lower_bound
#define ub upper_bound
#define all(v) (v).begin(), (v).end()
#define SZ(x) ((int)(x).size())
#define vi vector<int>
#define vvi vector<vector<int>>
#define vp vector<pair<int, int>>
#define vvp vector<vector<pair<int, int>>>
#define pi pair<int, int>
// #define P pair<int, int>
// #define V vector<int>
// #define S set<int>
#define asn ans

template <signed mod> struct NumberTheoreticTransform {
private:
  vector<signed> rev, rts; // swap計算用の配列, \omega^iに相当するもの
  signed base, max_base, root;
  inline signed mod_add(signed a, signed b) {
    a += b;
    if (a >= mod)
      a -= mod;
    return a;
  }
  inline signed mod_mul(signed a, signed b) {
    return (1ull * a * b) % (unsigned long long)mod;
  }
  inline signed mod_pow(signed a, signed n) {
    signed ret = 1;
    while (n) {
      if (n & 1)
        ret = mod_mul(ret, a);
      a = mod_mul(a, a);
      n >>= 1;
    }
    return ret;
  }
  inline signed mod_inv(signed a) { return mod_pow(a, mod - 2); }
  //
public:
  NumberTheoreticTransform() : base(1), rev{0, 1}, rts{0, 1} {
    assert(mod >= 3 && mod & 1 == 1);
    signed tmp = mod - 1;
    max_base = 0;
    while (tmp % 2 == 0) {
      tmp >>= 1;
      max_base++;
    }
    root = 2;
    while (mod_pow(root, (mod - 1) >> 1) == 1)
      root++;
    assert(mod_pow(root, mod - 1) == 1);
    root = mod_pow(root, (mod - 1) >> max_base);
  }
  //
private:
  void ensure_base(signed nbase) {
    if (nbase <= base)
      return;
    assert(nbase <= max_base);
    rev.resize(1 << nbase);
    rts.resize(1 << nbase);
    for (signed i = 0; i < (1 << nbase); i++) {
      rev[i] = (rev[i >> 1] >> 1) + ((i & 1) << (nbase - 1));
    }
    while (base < nbase) {
      signed z = mod_pow(root, 1 << (max_base - 1 - base));
      for (signed i = 1 << (base - 1); i < (1 << base); i++) {
        rts[i << 1] = rts[i];
        rts[(i << 1) + 1] = mod_mul(rts[i], z);
      }
      base++;
    }
  }
  void ntt(vector<signed> &a) {
    const signed n = (signed)a.size();
    assert((n & (n - 1)) == 0);
    signed zeros = __builtin_ctz(n);
    ensure_base(zeros);
    signed shift = base - zeros;
    for (signed i = 0; i < n; i++) {
      if (i < (rev[i] >> shift))
        swap(a[i], a[rev[i] >> shift]);
    }
    for (signed k = 1; k < n; k <<= 1) {
      for (signed i = 0; i < n; i += 2 * k) {
        for (signed j = 0; j < k; j++) {
          signed z = mod_mul(a[i + j + k], rts[j + k]);
          a[i + j + k] = mod_add(a[i + j], mod - z);
          a[i + j] = mod_add(a[i + j], z);
        }
      }
    }
  }
  //
public:
  vector<signed> multiply(vector<signed> a, vector<signed> b) {
    if (a.empty() || b.empty())
      return {};
    bool eq = (a == b);
    signed need = a.size() + b.size() - 1;
    signed nbase = 1;
    while ((1 << nbase) < need)
      nbase++;
    ensure_base(nbase);
    signed sz = 1 << nbase;
    a.resize(sz, 0);
    b.resize(sz, 0);
    ntt(a);
    if (eq)
      b = a;
    else
      ntt(b);
    signed inv_sz = mod_inv(sz);
    for (signed i = 0; i < sz; i++) {
      a[i] = mod_mul(a[i], mod_mul(b[i], inv_sz));
    }
    reverse(a.begin() + 1, a.end());
    ntt(a);
    a.resize(need);
    return a;
  }
  vector<long long> multiply(vector<long long> a, vector<long long> b) {
    vector<signed> A(a.size()), B(b.size());
    for (signed i = 0; i < a.size(); i++) {
      A[i] = a[i];
    }
    for (signed i = 0; i < b.size(); i++) {
      B[i] = b[i];
    }
    A = multiply(A, B);
    a.resize(A.size());
    for (signed i = 0; i < A.size(); i++)
      a[i] = A[i];
    return a;
  }
};

template <uint MD> struct ModInt {
  using M = ModInt;
  const static M G;
  uint v;
  ModInt(ll _v = 0) { set_v(_v % MD + MD); }
  M &set_v(uint _v) {
    v = (_v < MD) ? _v : _v - MD;
    return *this;
  }
  explicit operator bool() const { return v != 0; }
  M operator-() const { return M() - *this; }
  M operator+(const M &r) const { return M().set_v(v + r.v); }
  M operator-(const M &r) const { return M().set_v(v + MD - r.v); }
  M operator*(const M &r) const { return M().set_v(ull(v) * r.v % MD); }
  M operator/(const M &r) const { return *this * r.inv(); }
  M &operator+=(const M &r) { return *this = *this + r; }
  M &operator-=(const M &r) { return *this = *this - r; }
  M &operator*=(const M &r) { return *this = *this * r; }
  M &operator/=(const M &r) { return *this = *this / r; }
  bool operator==(const M &r) const { return v == r.v; }
  M pow(ll n) const {
    M x = *this, r = 1;
    while (n) {
      if (n & 1)
        r *= x;
      x *= x;
      n >>= 1;
    }
    return r;
  }
  M inv() const { return pow(MD - 2); }
  /*
  M inv() const {
      long long b = MD, u = 1, v = 0;
      long long a = (*this).v;
      while (b) {
          long long t = a / b;
          a -= t * b;
          swap(a, b);
          u -= t * v;
          swap(u, v);
      }
      u %= MD;
      if (u < 0)
          u += MD;
      return M{u};
  }
  */
  friend ostream &operator<<(ostream &os, const M &r) { return os << r.v; }
  friend istream &operator>>(istream &is, M &r) { return is >> r.v; }
};

using Mint = ModInt<MOD>;
const int MN = 2000010;
Mint fact[MN], iFac[MN];

void first() {
  fact[0] = Mint(1);
  for (int i = 1; i < MN; i++)
    fact[i] = fact[i - 1] * Mint(i);
  iFac[MN - 1] = fact[MN - 1].inv();
  for (int i = MN - 1; i >= 1; i--) {
    iFac[i - 1] = iFac[i] * Mint(i);
  }
  assert(fact[2345] * iFac[2345] == Mint(1));
}
Mint C(int n, int k) {
  if (n < k || k < 0)
    return Mint(0);
  return fact[n] * iFac[k] * iFac[n - k];
}

template <typename T> struct edge {
  int to, id;
  T cost;
  edge(int to) : to(to), id(-1), cost(1) {}
  edge(int to, T cost) : to(to), id(-1), cost(cost) {}
  edge(int to, T cost, int id) : to(to), id(id), cost(cost) {}
  operator int() const { return to; }
  /*
      edge& operator=(const int& x) {
          to = x;
          return *this;
      }
      */
};
template <typename T> class Graph : public vector<vector<edge<T>>> {
  //--------Basic--------
private:
  using Edge = edge<T>;
  int M; // M:辺の数
  bool undirected = false;
  bool directed = false;
  bool unweighted = false;
  bool weighted = false;
  bool tree = false;
  //
public:
  //
public:
  Graph() = default;
  // unweighted
  void add_edge_undirected(int u, int v, int id = -1) {
    assert(!directed);
    assert(!weighted);
    undirected = true;
    unweighted = true;
    (*this)[u].emplace_back(Edge{v, 1, id});
    (*this)[v].emplace_back(Edge{u, 1, id});
  }
  void build_undirected(int m) {
    assert(!(*this).empty());
    assert(!directed);
    assert(!weighted);
    undirected = true;
    unweighted = true;
    M = m;
    for (int i = 0; i < m; i++) {
      int u, v;
      cin >> u >> v;
      u--;
      v--;
      (*this)[u].emplace_back(Edge{v, 1, i});
      (*this)[v].emplace_back(Edge{u, 1, i});
    }
  }
  void build_undirected(int n, int m) {
    (*this).resize(n);
    build_undirected(m);
  }
  void add_edge_directed(int u, int v, int id = -1) {
    assert(!undirected);
    assert(!weighted);
    directed = true;
    unweighted = true;
    (*this)[u].emplace_back(Edge{v, 1, id});
  }
  void build_directed(int m) {
    assert(!(*this).empty());
    assert(!undirected);
    assert(!weighted);
    directed = true;
    unweighted = true;
    M = m;
    for (int i = 0; i < m; i++) {
      int u, v;
      cin >> u >> v;
      u--;
      v--;
      (*this)[u].emplace_back(Edge{v, 1, i});
    }
  }
  void build_directed(int n, int m) {
    (*this).resize(n);
    build_undirected(m);
  }
  // weighed
  void add_edge_undirected_weighed(int u, int v, T cost, int id = -1) {
    assert(!directed);
    assert(!unweighted);
    undirected = true;
    weighted = true;
    (*this)[u].emplace_back(Edge{v, cost, id});
    (*this)[v].emplace_back(Edge{u, cost, id});
  }
  void build_undirected_weighted(int m) {
    assert(!(*this).empty());
    assert(!directed);
    assert(!unweighted);
    undirected = true;
    weighted = true;
    M = m;
    for (int i = 0; i < m; i++) {
      int u, v;
      T cost;
      cin >> u >> v >> cost;
      u--;
      v--;
      (*this)[u].emplace_back(Edge{v, cost, i});
      (*this)[v].emplace_back(Edge{u, cost, i});
    }
  }
  void build_undirected_weighted(int n, int m) {
    (*this).resize(n);
    build_undirected(m);
  }
  void add_edge_directed_weighted(int u, int v, T cost, int id = -1) {
    assert(!undirected);
    assert(!unweighted);
    directed = true;
    weighted = true;
    (*this)[u].emplace_back(Edge{v, cost, id});
  }
  void build_directed_weighted(int m) {
    assert(!(*this).empty());
    assert(!undirected);
    assert(!unweighted);
    directed = true;
    weighted = true;
    M = m;
    for (int i = 0; i < m; i++) {
      int u, v;
      T cost;
      cin >> u >> v >> cost;
      u--;
      v--;
      (*this)[u].emplace_back(Edge{v, cost, i});
    }
  }
  void build_directed_weighted(int n, int m) {
    (*this).resize(n);
    build_undirected(m);
  }
  // tree
  void istree() { tree = true; }
  void build_tree(int n) {
    istree();
    build_undirected(n, n - 1);
  }
  void build_tree_weighted(int n) {
    istree();
    build_undirected_weighted(n, n - 1);
  }
  // print state
  void state() {
    cerr << endl
         << "Print State" << endl
         << "Edge :" << endl
         << "    Directed   : " << (directed ? "Yes" : "No") << endl
         << "    Undirected : " << (undirected ? "Yes" : "No") << endl
         << "    Weighted   : " << (weighted ? "Yes" : "No") << endl
         << "    Unweighted : " << (unweighted ? "Yes" : "No") << endl
         << "    Tree       : " << (tree ? "Yes" : "No") << endl
         << "Usable Functions : Graph" << endl
         << "    StronglyConnectedComponent(unverified): "
         << (StronglyConnectedComponent_ready ? "Yes" : "No") << endl
         << "Usable Funcitons : Tree" << endl
         << "    ReRooting(verified) : Yes" << endl;
  }
  //
  //
  //
  //--------StronglyConnectedComponent--------
  // Unverified
public:
  vector<vector<int>> SCC_R, SCC_T;
  //
private:
  bool StronglyConnectedComponent_ready = false;
  vector<int> SCC_cmp, SCC_ord;
  vector<bool> SCC_used;
  //
public:
  int SCC_build() {
    cerr << "Please Verify" << endl;
    assert(!undirected);
    assert(directed);
    int N = (*this).size();
    SCC_R.resize(N);
    for (int i = 0; i < N; i++) {
      for (int &x : (*this)[i]) {
        SCC_R[x].emplace_back(i);
      }
    }
    SCC_cmp.resize(N);
    fill(SCC_cmp.begin(), SCC_cmp.end(), -1);
    SCC_used.resize(N);
    fill(SCC_used.begin(), SCC_used.end(), false);
    StronglyConnectedComponent_ready = true;
    return build_StronglyConnectedComponent_init();
  }
  int SCC(int k) {
    assert(StronglyConnectedComponent_ready);
    return SCC_cmp[k];
  }
  //
private:
  void dfs(int now) {
    if (SCC_used[now])
      return;
    SCC_used[now] = true;
    for (auto nxt : (*this)[now])
      dfs(nxt);
    SCC_ord.emplace_back(now);
  }
  void rdfs(int now, int count) {
    if (SCC_cmp[now] != -1)
      return;
    SCC_cmp[now] = count;
    for (auto to : SCC_R[now])
      rdfs(to, count);
  }
  int build_StronglyConnectedComponent_init() {
    int n = (int)(*this).size();
    for (int i = 0; i < n; i++)
      dfs(i);
    reverse(SCC_ord.begin(), SCC_ord.end());
    int group = 0;
    for (auto &i : SCC_ord) {
      if (SCC_cmp[i] == -1) {
        rdfs(i, group);
        group++;
      }
    }
    SCC_T.resize(group);
    for (int i = 0; i < n; i++) {
      for (auto &to : (*this)[i]) {
        int s = SCC_cmp[i], t = SCC_cmp[to];
        if (s != t)
          SCC_T[s].emplace_back(t);
      }
    }
    return group;
  }
  //
  //
  //
  //--------TopologicalSort--------
  // 未実装
  //
  //
  //
  //--------Tree--------
  //
  //
  //--------ReRooting--------
  // unverified
private:
  template <typename sum_t>
  void
  ReRooting_dfs_sub(int idx, int par, const function<sum_t(sum_t, sum_t)> &f,
                    const function<sum_t(sum_t, Edge)> &gg, const sum_t &ident,
                    vector<sum_t> &subdp, vector<sum_t> &dp,
                    vector<vector<sum_t>> &g_dp, vector<vector<sum_t>> &g_ndp,
                    vector<vector<sum_t>> &memo, vector<vector<bool>> &seen) {
    for (int i = 0; i < (int)((*this)[idx].size()); i++) {
      auto &e = (*this)[idx][i];
      if (e.to == par)
        continue;
      ReRooting_dfs_sub<sum_t>(e.to, idx, f, gg, ident, subdp, dp, g_dp, g_ndp,
                               memo, seen);
      if (!seen[idx][i]) {
        memo[idx][i] = gg(subdp[e.to], e);
        seen[idx][i] = true;
      }
      subdp[idx] = f(subdp[idx], memo[idx][i]);
    }
  }
  template <typename sum_t>
  void
  ReRooting_dfs_all(int idx, int par, const sum_t &top,
                    const function<sum_t(sum_t, sum_t)> &f,
                    const function<sum_t(sum_t, Edge)> &gg, const sum_t &ident,
                    vector<sum_t> &subdp, vector<sum_t> &dp,
                    vector<vector<sum_t>> &g_dp, vector<vector<sum_t>> &g_ndp,
                    vector<vector<sum_t>> &memo, vector<vector<bool>> &seen) {
    sum_t buff{ident};
    for (int i = 0; i < (int)((*this)[idx].size()); i++) {
      auto &e = (*this)[idx][i];
      g_ndp[idx][i] = buff;
      if (!seen[idx][i]) {
        memo[idx][i] = gg(par == e.to ? top : subdp[e.to], e);
        seen[idx][i] = true;
      }
      g_dp[idx][i] = memo[idx][i];
      buff = f(buff, g_dp[idx][i]);
    }
    dp[idx] = buff;
    buff = ident;
    for (int i = (*this)[idx].size() - 1; i >= 0; i--) {
      auto &e = (*this)[idx][i];
      if (e.to != par)
        ReRooting_dfs_all<sum_t>(e.to, idx, f(g_ndp[idx][i], buff), f, gg,
                                 ident, subdp, dp, g_dp, g_ndp, memo, seen);
      g_ndp[idx][i] = f(g_ndp[idx][i], buff);
      buff = f(buff, g_dp[idx][i]);
    }
  }
  //
public:
  template <typename sum_t>
  pair<vector<sum_t>, vector<vector<sum_t>>>
  Tbuild_ReRooting(const function<sum_t(sum_t, sum_t)> f,
                   const function<sum_t(sum_t, Edge)> gg, sum_t ident) {
    assert(tree);
    int N = (*this).size();
    vector<sum_t> subdp(N, ident), dp(N, ident);
    vector<vector<sum_t>> g_dp(N), g_ndp(N), memo(N);
    vector<vector<bool>> seen(N);
    for (int i = 0; i < N; i++) {
      int S = (*this)[i].size();
      g_dp[i].resize(S, ident);
      g_ndp[i].resize(S, ident);
      memo[i].resize(S);
      seen[i].resize(S, false);
    }
    stack<int> stk;
    stk.push(0);
    vector<int> par(N), ord(N);
    int index = 0;
    par[0] = -1;
    while (!stk.empty()) {
      int node = stk.top();
      stk.pop();
      ord[index++] = node;
      for (auto &e : (*this)[node]) {
        if (e.to == par[node])
          continue;
        stk.push(e.to);
        par[e.to] = node;
      }
    }
    for (int k = ord.size() - 1; k >= 0; k--) {
      int idx = ord[k];
      for (int i = 0; i < (int)((*this)[idx].size()); i++) {
        auto &e = (*this)[idx][i];
        if (e.to == par[idx])
          continue;
        if (!seen[idx][i]) {
          memo[idx][i] = gg(subdp[e.to], e);
          seen[idx][i] = true;
        }
        subdp[idx] = f(subdp[idx], memo[idx][i]);
      }
    }
    vector<sum_t> top(N, ident);
    for (int k = 0; k < (int)(ord.size()); k++) {
      int idx = ord[k];
      sum_t buff{ident};
      for (int i = 0; i < (int)((*this)[idx].size()); i++) {
        auto &e = (*this)[idx][i];
        g_ndp[idx][i] = buff;
        if (!seen[idx][i]) {
          memo[idx][i] = gg(par[idx] == e.to ? top[idx] : subdp[e.to], e);
          seen[idx][i] = true;
        }
        g_dp[idx][i] = memo[idx][i];
        buff = f(buff, g_dp[idx][i]);
      }
      dp[idx] = buff;
      buff = ident;
      for (int i = (*this)[idx].size() - 1; i >= 0; i--) {
        auto &e = (*this)[idx][i];
        if (e.to != par[idx])
          top[e.to] = f(g_ndp[idx][i], buff);
        g_ndp[idx][i] = f(g_ndp[idx][i], buff);
        buff = f(buff, g_dp[idx][i]);
      }
    }
    return make_pair(dp, memo);
  }
};
// グローバルでの使用のみ想定

template <typename sum_t, typename key_t> struct ReRooting {
  struct Edge {
    int to;
    key_t data;
    sum_t dp, ndp;
  };

  using F = function<sum_t(sum_t, sum_t)>;
  using G = function<sum_t(sum_t, key_t)>;

  vector<vector<Edge>> g;
  vector<sum_t> subdp, dp;
  const sum_t ident;
  const F f;
  const G gg;

  ReRooting(int V, const F f, const G g, const sum_t &ident)
      : g(V), f(f), gg(g), ident(ident), subdp(V, ident), dp(V, ident) {}

  void add_edge(int u, int v, const key_t &d) {
    g[u].emplace_back((Edge){v, d, ident, ident});
    g[v].emplace_back((Edge){u, d, ident, ident});
  }

  void add_edge_bi(int u, int v, const key_t &d, const key_t &e) {
    g[u].emplace_back((Edge){v, d, ident, ident});
    g[v].emplace_back((Edge){u, e, ident, ident});
  }

  void dfs_sub(int idx, int par) {
    for (auto &e : g[idx]) {
      if (e.to == par)
        continue;
      dfs_sub(e.to, idx);
      subdp[idx] = f(subdp[idx], gg(subdp[e.to], e.data));
    }
  }

  void dfs_all(int idx, int par, const sum_t &top) {
    sum_t buff{ident};
    for (int i = 0; i < (int)g[idx].size(); i++) {
      auto &e = g[idx][i];
      e.ndp = buff;
      e.dp = gg(par == e.to ? top : subdp[e.to], e.data);
      buff = f(buff, e.dp);
    }
    dp[idx] = buff;
    buff = ident;
    for (int i = (int)g[idx].size() - 1; i >= 0; i--) {
      auto &e = g[idx][i];
      if (e.to != par)
        dfs_all(e.to, idx, f(e.ndp, buff));
      e.ndp = f(e.ndp, buff);
      buff = f(buff, e.dp);
    }
  }

  vector<sum_t> build() {
    dfs_sub(0, -1);
    dfs_all(0, -1, ident);
    return dp;
  }
};
// https://ei1333.hateblo.jp/entry/2018/12/21/004022

Graph<int> G;

int N, a[202020], b[202020];
int memo[202020] = {};
int memo2[202020] = {};

void solve() {
  vector<Mint> cnt(N, Mint{0});
  ReRooting<int, int> g(
      N, [](int a, int b) { return a + b; },
      [&](int x, int i) {
        memo[i] = x + 1;
        return x + 1;
      },
      0);
  for (int i = 0; i < N - 1; i++) {
    g.add_edge(a[i], b[i], i);
  }
  g.build();

  /*
  G.istree();
  G.Tbuild_ReRooting<int>(
      [](int a, int b) { return a + b; },
      [&](int x, edge<int> e) {
          int i = e.id;
          memo2[i] = x + 1;
          return x + 1;
      },
      0);
  */

  for (int i = 0; i < N - 1; i++) {
    if (memo[i] == 0)
      continue;
    cnt[memo[i]] += 1;
    cnt[N - memo[i]] += 1;
  }

  first();
  vector<int> A(N, 0), B(N + 1, 0);
  for (int i = 0; i < N; i++) {
    A[i] = (fact[i] * cnt[i]).v;
  }
  for (int i = 0; i <= N; i++) {
    B[i] = iFac[N - i].v;
  }

  NumberTheoreticTransform<MOD> ntt;
  auto ans = ntt.multiply(A, B);

  for (int K = 1; K <= N; K++) {
    cout << (int)(C(N, K) * N - iFac[K] * ans[N + K]).v << endl;
  }
}

signed main() {

  cin >> N;
  G.resize(N);
  for (int i = 0; i < N - 1; i++) {
    cin >> a[i] >> b[i];
    a[i]--;
    b[i]--;
    G.add_edge_undirected(a[i], b[i], i);
  }
  // G.build_tree(N);

  solve();
  return 0;
}