#include <bits/stdc++.h>

using namespace std;

inline void read() {}
template <class S>
inline void read(S &arg) {
  cin >> arg;
}
template <class S>
inline void readA(S Lptr, S Rptr) {
  while (Lptr != Rptr) {
    read(*Lptr);
    Lptr++;
  }
}
template <class S, class... T>
inline void read(S &arg, T &... rest) {
  read(arg);
  read(rest...);
}

inline void write() {}
template <class S>
inline void write(S arg) {
  cout << arg;
}
template <class S>
inline void writeA(S Lptr, S Rptr) {
  if (Lptr != Rptr) {
    write(*Lptr);
    Lptr++;
  }
  while (Lptr != Rptr) {
    write(' ');
    write(*Lptr);
    Lptr++;
  }
}
template <class S, class... T>
inline void write(S arg, T... rest) {
  write(arg);
  write(' ');
  write(rest...);
}

#define rep(i, j, k) for (int i = j; i < (int)k; i++)
#define pb push_back
#define mt make_tuple
#define all(x) x.begin(), x.end()

typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;

template <class T, class S>
inline bool smin(T &a, S b) {
  return (T)b < a ? a = b, 1 : 0;
}
template <class T, class S>
inline bool smax(T &a, S b) {
  return a < (T)b ? a = b, 1 : 0;
}

constexpr int MOD = 924844033;
constexpr int N = (1 << 20) + 10;

template <typename T>
inline T mod(T &v) {
  return v = (v % MOD + MOD) % MOD;
}
template <typename S, typename T>
inline S add(S &l, T r) {
  return mod(l += r);
}
struct convolution {
  const int mod1 = 924844033;
  const int mod2 = 1004535809;

  typedef vector<int> vi;

  inline int loger(int v) {
    int res = 0;
    while (v) {
      res++;
      v >>= 1;
    }
    return res;
  }

  inline int po(int v, int u, const int mod) {
    int res = 1;
    for (int i = 30; ~i; i--) {
      res = (1ll * res * res) % mod;
      if (u & (1 << i)) res = (1ll * res * v) % mod;
    }
    return res;
  }

  inline void NTT(vi &a, const int mod, const int limit, bool inverse = false) {
    for (int i = 0; i < (1 << limit); i++) {
      int rev = 0;
      for (int j = 0; j < limit; j++)
        if ((i >> j) & 1) rev ^= 1 << (limit - j - 1);
      if (rev > i) swap(a[i], a[rev]);
    }
    for (int len = 1; len < (1 << limit); len <<= 1) {
      int w = po(5, (mod - 1) / (len << 1), mod);
      if (inverse) w = po(w, mod - 2, mod);
      for (int i = 0; i < (1 << limit); i += (len << 1)) {
        int step = 1;
        for (int j = 0; j < len; j++) {
          int u = a[i + j];
          int v = a[i + j + len];
          v = (1ll * v * step) % mod;
          a[i + j] = (u + v) % mod;
          a[i + j + len] = (u - v + mod) % mod;
          step = (1ll * step * w) % mod;
        }
      }
    }
    if (inverse) {
      int step = po(1 << limit, mod - 2, mod);
      for (int i = 0; i < (1 << limit); i++) a[i] = (1ll * a[i] * step) % mod;
    }
  }

  vi a, b, c;

  inline void conv(int a_[], const int la, int b_[], const int lb, int c_[]) {
    int lc = la + lb - 1;
    lc = loger(lc);
    a = vi(1 << lc);
    b = vi(1 << lc);
    c = vi(1 << lc);
    rep(i, 0, la) a[i] = a_[i];
    rep(i, 0, lb) b[i] = b_[i];
    NTT(a, mod1, lc);
    NTT(b, mod1, lc);
    c.resize(1 << lc);
    rep(i, 0, 1 << lc) c[i] = (1ll * a[i] * b[i]) % mod1;
    NTT(c, mod1, lc, true);
    rep(i, 0, la + lb - 1) c_[i] = c[i];
    return;
  }
} ziba;

ll po(ll v, ll u) {
  return u ? po(v * v % MOD, u >> 1) * (u & 1 ? v : 1) % MOD : 1;
}

int n, sz[N];
vi adj[N];

void dfs(int v, int par = 0) {
  sz[v]++;
  for (auto e : adj[v])
    if (e ^ par) {
      dfs(e, v);
      sz[v] += sz[e];
    }
}

ll f[N];
int a[N], b[N], c[N];

inline ll C(int z) { return (f[n] * po(f[z] * f[n - z] % MOD, MOD - 2)) % MOD; }

int main() {
  ios::sync_with_stdio(0);
  cin.tie(0);
  cout.tie(0);

  f[0] = 1;
  rep(i, 1, N) f[i] = (f[i - 1] * i) % MOD;

  read(n);
  rep(i, 1, n) {
    int u, v;
    read(u, v);
    adj[u].pb(v);
    adj[v].pb(u);
  }

  dfs(1);

  rep(i, 2, n + 1) {
    add(a[sz[i]], f[sz[i]]);
    add(a[n - sz[i]], f[n - sz[i]]);
  }

  rep(i, 0, n + 1) b[i] = po(f[n - i], MOD - 2);

  ziba.conv(a, n + 1, b, n + 1, c);
  rep(k, 1, n + 1) {
    ll A = (n * C(k)) % MOD;
    ll B = (1ll * c[n + k] * b[n - k]) % MOD;
    cout << (A - B + MOD) % MOD << '\n';
  }
  return 0;
}

// i / i - j
// i + n - (i - j)
// n + j

Measured memory_bytes: 65664