#include <bits/stdc++.h>
// #include <boost/multiprecision/cpp_int.hpp>
// using i128 = boost::multiprecision::int128_t;
#define _GLIBCXX_DEBUG
using namespace std;
using ll = long long;
using ld = long double;
using V = vector<int>;
using Vll = vector<ll>;
using Vld = vector<ld>;
using Vbo = vector<bool>;
using VV = vector<V>;
using VVll = vector<Vll>;
using VVld = vector<Vld>;
using VVbo = vector<Vbo>;
using VVV = vector<VV>;
using VVVll = vector<VVll>;
using P = pair<int, int>;
using Pll = pair<ll, ll>;
using Pld = pair<ld, ld>;
#define rep2(i, m, n) for(int i=int(m); i<int(n); ++i)
#define drep2(i, m, n) for(int i=int(m)-1; i>=int(n); --i)
#define rep(i, n) rep2(i, 0, n)
#define drep(i, n) drep2(i, n, 0)
#define all(a) a.begin(), a.end()
struct fast_ios { fast_ios(){ cin.tie(nullptr); ios::sync_with_stdio(false); cout << fixed << setprecision(20); }; } fast_ios_;
template<typename T> inline int sz(T &x) { return x.size(); }
template<typename T> inline bool chmin(T &a, T b) { if (a > b) { a = b; return true; } return false; }
template<typename T> inline bool chmax(T &a, T b) { if (a < b) { a = b; return true; } return false; }
template<typename T1, typename T2> istream &operator>>(istream &is, pair<T1, T2> &p) { is >> p.first >> p.second; return is; }
template<typename T1, typename T2> ostream &operator<<(ostream &os, const pair<T1, T2> &p) { os << "(" << p.first << ", " << p.second << ")"; return os; }
template<typename T> istream &operator>>(istream &is, vector<T> &v) { for (auto &e : v) is >> e; return is; }
template<typename T> ostream &operator<<(ostream &os, const vector<T> &v) { for (auto &e : v) os << e << " "; return os; }
template<typename T> inline int count_between(vector<T> &a, T l, T r) { return lower_bound(all(a), r) - lower_bound(all(a), l); } // [l, r)
inline int fLog2(const int x) { return 31-__builtin_clz(x); } // floor(log2(x))
inline int fLog2(const ll x) { return 63-__builtin_clzll(x); }
inline int cLog2(const int x) { return (x == 1) ? 0 : 32-__builtin_clz(x-1); } // ceil(log2(x))
inline int cLog2(const ll x) { return (x == 1) ? 0 : 64-__builtin_clzll(x-1); }
inline int popcount(const int x) { return __builtin_popcount(x); }
inline int popcount(const ll x) { return __builtin_popcountll(x); }
const int INF  = 1<<30;
const ll INFll = 1ll<<62;
const ld EPS   = 1e-10;
const ld PI    = acos(-1.0);
// const int MOD  = int(1e9)+7;

const int MOD  = 924844033;
const int root = 5;

// pairs of mod and root
// (924844033, 5)
// (998244353, 3)
// (1012924417, 5)
// (167772161, 3)
// (469762049, 3)
// (1224736769, 3)

int add(const int x, const int y) { return (x + y < MOD) ? x + y : x + y - MOD; }
int sub(const int x, const int y) { return (x >= y) ? (x - y) : (MOD - y + x); }
int mul(const int x, const int y) { return ll(x) * y % MOD; }
int mod_pow(int x, int n) {
  int res = 1;
  for (; n > 0; n >>= 1){
    if (n&1) res = mul(res, x);
    x = mul(x, x);
  }
  return res;
}
int inverse(const int x) { return mod_pow(x, MOD - 2); }
 
void ntt(V &a, const bool rev = false) {
  int i, j, k, l, p, q, r, s;
  const int size = a.size();
  if (size == 1) return;
  V b(size);
  r = rev ? (MOD - 1 - (MOD - 1) / size) : (MOD - 1) / size;
  s = mod_pow(root, r);
  V kp(size / 2 + 1, 1);
  for (i = 0; i < size / 2; ++i) kp[i + 1] = mul(kp[i], s);
  for (i = 1, l = size / 2; i < size; i <<= 1, l >>= 1) {
    for (j = 0, r = 0; j < l; ++j, r += i) {
      for (k = 0, s = kp[i * j]; k < i; ++k) {
        p = a[k + r], q = a[k + r + size / 2];
        b[k + 2 * r] = add(p, q);
        b[k + 2 * r + i] = mul(sub(p, q), s);
      }
    }
    swap(a, b);
  }
  if (rev) {
    s = inverse(size);
    for(i = 0; i < size; i++){ a[i] = mul(a[i], s); }
  }
}

void conv(V &a, V b) {
  const int size = sz(a) + sz(b) - 1;
  int t = 1;
  while (t < size) { t <<= 1; }
  a.resize(t); ntt(a);
  b.resize(t); ntt(b);
  rep(i, t) a[i] = mul(a[i], b[i]);
  ntt(a, true);
  a.resize(size);
}

V shift(V poly, int c) {
  int n = poly.size();
  V inv(n + 1), fact(n + 1), invfact(n + 1);
  inv[1] = invfact[1] = invfact[0] = fact[0] = fact[1] = 1;
  for (int i = 2; i <= n; i++) {
    fact[i] = mul(fact[i - 1], i);
    inv[i] = mul(inv[MOD % i], MOD - MOD / i);
    invfact[i] = mul(invfact[i - 1], inv[i]);
  }
  for (int i = 0; i < poly.size(); i++) {
    poly[i] = mul(poly[i], fact[i]);
  }
  int val = 1;
  V shifting(n);
  for (int i = 0; i < n; i++) {
    shifting[n - i - 1] = mul(val, invfact[i]);
    val = mul(val, c);
  }
  conv(poly, shifting);
  V ans(n);
  for (int i = 0; i < n; i++) {
    ans[i] = mul(poly[n - 1 + i], invfact[i]);
  }
  return ans;
}


struct mint {
  ll x;
  mint(ll x=0) : x((x%MOD+MOD)%MOD) {}
  mint operator-() const { return mint(-x);}
  mint& operator+=(const mint a) { if ((x += a.x) >= MOD) x -= MOD; return *this; }
  mint& operator-=(const mint a) { if ((x -= a.x) < 0) x += MOD; return *this; }
  mint& operator*=(const mint a) { (x *= a.x) %= MOD; return *this; }
  mint operator+(const mint a) const { return mint(*this) += a; }
  mint operator-(const mint a) const { return mint(*this) -= a; }
  mint operator*(const mint a) const { return mint(*this) *= a; }
  mint pow(ll t) const {
    if (!t) return 1;
    mint a = pow(t>>1);
    a *= a;
    if (t&1) a *= *this;
    return a;
  }
  mint& operator/=(const mint r) {
    ll a = r.x, b = MOD, u = 1, v = 0;
    while (b) {
      ll t = a / b;
      a -= t * b; swap(a, b);
      u -= t * v; swap(u, v);
    }
    x = x * u % MOD;
    if (x < 0) x += MOD;
    return *this;
  }
  mint operator/(const mint a) const { return mint(*this) /= a; }
};
// istream& operator>>(istream& is, mint& a) { return is >> a.x; }
ostream& operator<<(ostream& os, const mint& a) { return os << a.x; }
using Vm = vector<mint>;
using VVm = vector<Vm>;
using VVVm = vector<VVm>;


// initialization
const int F_MAX = int(2e5)+10;
ll fac[F_MAX], finv[F_MAX], inv[F_MAX];
void binom_init() {
  fac[0] = fac[1] = 1;
  finv[0] = finv[1] = 1;
  inv[1] = 1;
  for (int i = 2; i < F_MAX; ++i) {
    fac[i] = fac[i-1] * i % MOD;
    inv[i] = MOD - inv[MOD%i] * (MOD/i) % MOD;
    finv[i] = finv[i-1] * inv[i] % MOD;
  }
}

mint binom(int n, int k) {
  if (k < 0 || n < k) return 0;
  return fac[n] * (finv[k] * finv[n-k] % MOD);
}


int n;
VV G;
V cnt;

int dfs(int u, int p=-1) {
  int res = 1;
  for (int v : G[u]) if (v != p) {
    int x = dfs(v, u);
    ++cnt[x];
    ++cnt[n-x];
    res += x;
  }
  return res;
}

int main() {
  binom_init();
  cin >> n;
  G.assign(n, V());
  cnt.assign(n, 0);
  rep(i, n-1) {
    int u, v; cin >> u >> v;
    --u, --v;
    G[u].push_back(v);
    G[v].push_back(u);
  }

  dfs(0);
  auto p = shift(cnt, 1);
  p.push_back(0);

  Vm ans(n+1);
  rep(i, n+1) ans[i] = binom(n, i) * n - p[i];
  rep(i, n) cout << ans[i+1] << '\n';
  return 0;
}


Measured memory_bytes: 37836