#include <algorithm>
#include <cassert>
#include <cstring>
#include <iostream>
#include <vector>

using namespace std;

#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define TRACE(x) cout << #x << " = " << x << endl
#define _ << " _ " <<

typedef long long llint;

const int mod = 924844033;

inline int add(int a, int b) { return a + b >= mod ? a + b - mod : a + b; }

inline int sub(int a, int b) { return a >= b ? a - b : a - b + mod; }

inline int mul(int a, int b) { return llint(a) * b % mod; }

namespace NTT {
int g = 0;  // !

int powmod(int a, int b) {
  if (b == 0) return 1;
  if (b & 1) return mul(a, powmod(a, b - 1));
  return powmod(mul(a, a), b / 2);
}

void findPrimitiveRoot() {
  if (g) return;

  vector<int> d;
  for (int i = 2; i * i <= mod - 1; ++i)
    if ((mod - 1) % i == 0) d.push_back(i), d.push_back((mod - 1) / i);
  for (g = 2;; g++) {
    bool ok = true;
    for (int x : d) ok &= powmod(g, x) != 1;
    if (ok) break;
  }
}

void transform(int* a, int* z, int* omega, int m, int N) {
  if (m == 1) {
    z[0] = a[0];
  } else {
    int s = N / m;
    m /= 2;

    transform(a, z, omega, m, N);
    transform(a + s, z + m, omega, m, N);

    REP(i, m) {
      int c = mul(omega[s * i], z[m + i]);
      z[m + i] = sub(z[i], c);
      z[i] = add(z[i], c);
    }
  }
}

vector<int> fft(vector<int>& a) {
  findPrimitiveRoot();

  int N = a.size();
  int w = powmod(g, (mod - 1) / N);
  vector<int> omega(N);
  omega[0] = 1;
  FOR(i, 1, N) omega[i] = mul(omega[i - 1], w);

  vector<int> z(N);
  transform(a.data(), z.data(), omega.data(), N, N);
  return z;
}

vector<int> ifft(vector<int>& a) {
  findPrimitiveRoot();

  int N = a.size();
  int wi = powmod(powmod(g, (mod - 1) / N), mod - 2);
  vector<int> omega(N);
  omega[0] = 1;
  FOR(i, 1, N) omega[i] = mul(omega[i - 1], wi);

  vector<int> z(N);
  transform(a.data(), z.data(), omega.data(), N, N);

  int invN = powmod(N, mod - 2);
  REP(i, N) z[i] = mul(z[i], invN);
  return z;
}

vector<int> mult(vector<int> a, vector<int> b) {
  int N = a.size() + b.size();
  while (N & (N - 1)) ++N;

  a.resize(N, 0);
  b.resize(N, 0);

  vector<int> ta(move(fft(a)));
  vector<int> tb(move(fft(b)));
  REP(i, N) ta[i] = mul(ta[i], tb[i]);
  return ifft(ta);
}
};  // namespace NTT

const int MAX = 200200;

int fact[MAX];
int inv[MAX];
int invfact[MAX];

vector<int> E[MAX];
int sz[MAX];

void dfs(int x, int dad) {
  sz[x] = 1;
  for (int y : E[x]) {
    if (y == dad) continue;
    dfs(y, x);
    sz[x] += sz[y];
  }
}

int choose(int n, int k) {
  return mul(fact[n], mul(invfact[k], invfact[n - k]));
}

int main(void) {
  inv[1] = 1;
  FOR(i, 2, MAX) inv[i] = sub(0, mul(mod / i, inv[mod % i]));

  fact[0] = invfact[0] = 1;
  FOR(i, 1, MAX) {
    fact[i] = mul(fact[i - 1], i);
    invfact[i] = mul(invfact[i - 1], inv[i]);
  }

  ios_base::sync_with_stdio(false);

  int N;
  cin >> N;
  REP(i, N - 1) {
    int a, b;
    cin >> a >> b;
    --a, --b;
    E[a].push_back(b);
    E[b].push_back(a);
  }

  dfs(0, -1);

  vector<int> cnt(N + 1);
  FOR(i, 1, N) {
    cnt[sz[i]]++;
    cnt[N - sz[i]]++;
  }

  vector<int> a(N + 1);
  REP(i, N + 1) a[i] = mul(cnt[i], fact[i]);

  vector<int> b(N + 1);
  REP(i, N + 1) b[i] = invfact[N - i];

  vector<int> c(move(NTT::mult(a, b)));

  for (int k = 1; k <= N; ++k) {
    int total = mul(choose(N, k), N);
    int bad = mul(c[N + k], invfact[k]);
    int good = sub(total, bad);
    cout << good << "\n";
  }
  return 0;
}


Measured memory_bytes: 39644