#include <bits/stdc++.h>

using namespace std;
using ll = long long;
using ull = unsigned long long;
using uint = unsigned int;
template <class T> using V = vector<T>;
template <class T> using VV = V<V<T>>;

const int G = 5;
const int MD = 924844033;

struct Mint {
    using M = Mint;
    int v;
    Mint(int _v = 0) : v(_v) {}
    M& operator += (const M &r) {
        if ((v += r.v) >= MD) v -= MD;
        return *this;
    }
    M& operator *= (const M &r) {
        v = ll(v)*r.v%MD;
        return *this;
    }
    M& operator -= (const M &r) {
        if ((v -= r.v) < 0) v += MD;
        return *this;
    }
    M operator + (const M &r) const { return M(*this) += r; }
    M operator * (const M &r) const { return M(*this) *= r; }
    M operator - (const M &r) const { return M(*this) -= r; }
    M pow(int 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); }
};

const int MN = 200010;
const int MB = 19;
int n;
V<int> g[MN];
int cnt[MN];
int rev[1<<MB];
Mint fac[MN], ifac[MN];

int dfs(int v, int p) {
    int sz = 1;
    for (auto &u : g[v]) {
        if (u == p) continue;
        int csz = dfs(u, v);
        sz += csz;
        cnt[csz]++;
    }
    cnt[n-sz]++;
    return sz;
}

void first() {
    fac[0] = 1;
    for (int i = 1; i < MN; i++) fac[i] = Mint(i) * fac[i-1];
    for (int i = 0; i < MN; i++) ifac[i] = fac[i].inv();
    for (int i = 0; i < (1<<MB); i++) {
        rev[i] = (rev[i>>1]>>1)|((i&1)<<(MB-1));
    }
}

void ntt(V<Mint> &a) {
    int n = int(a.size());
    int s = MB - __builtin_ctz(n);
    for (int i = 0; i < n; i++) {
        int r = rev[i]>>s;
        if (i < r) swap(a[i], a[r]);
    }

    V<Mint> roots(n/2);
    roots[0] = 1;
    for (int k = 1; k < n; k *= 2) {
        Mint r = Mint(G).pow((MD-1)/(2*k));
        assert(r.pow(2*k).v == 1);
        for (int i = 0; i < k-1; i++) {
            roots[i+1] = r*roots[i];
        }
        for (int i = 0; i < n; i += 2*k) {
            for (int j = 0; j < k; j++) {
                auto l = a[i+j];
                auto r = a[i+j+k]*roots[j];
                a[i+j] = l+r;
                a[i+j+k] = l-r;
            }
        }
    }
}

V<Mint> pmul(V<Mint> a, V<Mint> b) {
    int A = int(a.size()), B = int(b.size());
    int n = 1;
    while (n < A+B-1) n *= 2;
    a.resize(n); ntt(a);
    b.resize(n); ntt(b);
    Mint in = Mint(n).inv();
    for (int i = 0; i < n; i++) {
        a[i] = in * a[i] * b[i];
    }
    reverse(a.begin()+1, a.end());
    ntt(a); a.resize(A+B-1);
    return a;
}

Mint C(int x, int y) {
    if (x < y || x < 0 || y < 0) return 0;
    return fac[x] * ifac[y] * ifac[x-y];
}

int main() {
    first();
    scanf("%d", &n);
    for (int i = 0; i < n-1; i++) {
        int a, b;
        scanf("%d %d", &a, &b); a--; b--;
        g[a].push_back(b);
        g[b].push_back(a);
    }
    dfs(0, -1);

    V<Mint> x(n+1), y(n+1);
    for (int i = 0; i <= n; i++) {
        x[i] = fac[i] * Mint(cnt[i]);
    }
    for (int i = 0; i <= n; i++) {
        y[i] = ifac[n-i];
    }
    x = pmul(x, y);

    for (int i = 1; i <= n; i++) {
        Mint ans = Mint(n) * C(n, i) - x[n+i] * ifac[i];
        printf("%d\n", ans.v);
    }
    return 0;
}

Measured memory_bytes: 30180