#include<bits/stdc++.h>

using namespace std;

int N, mod, fac[200009], inv[200009], ap[200009], vol[200009], ans[200009];
vector < int > v[200009];

int Konst = 1000, first_term[530009], second_term[530009], pol_result[530009], rev[530009];

double PI = acos (-1.0);
struct comp
{
    double a, b;///a + bi
    comp (): a (0.0), b (0.0) {}
    comp (double _a, double _b): a (_a), b (_b) {}
    comp (int val): a (val), b (0.0) {}
};
comp unit (int N) {comp x; x.a = (double) cos (2.0 * PI / N), x.b = sin (2.0 * PI / N); return x;}
comp operator / (comp x, double val) {return comp (x.a / val, x.b / val);}
comp operator - (comp a, comp b) {return comp (a.a - b.a, a.b - b.b);}
comp operator + (comp a, comp b) {return comp (a.a + b.a, a.b + b.b);}
comp operator * (comp a, comp b) {return comp (1.0 * a.a * b.a - 1.0 * a.b * b.b, 1.0 * a.b * b.a + 1.0 * a.a * b.b);}

void DFT (comp a[], int N, bool inv)
{
    for (int i=0; i<N; i++)
        if (i < rev[i]) swap (a[i], a[rev[i]]);
    for (int l=2; l<=N; l <<= 1)
    {
        comp omega = unit (l);
        if (inv) omega = unit (-l);
        for (int i=0; i<N; i+=l)
        {
            comp put = comp(1.0);
            for (int j=0; j<l / 2; j++)
            {
                comp u = a[i + j], v = a[i + j + l / 2] * put;
                a[i + j] = u + v;
                a[i + j + l / 2] = u - v;
                put = put * omega;
            }
        }
    }
    if (inv)
    {
        for (int i=0; i<N; i++)
            a[i] = a[i] / N;
    }
}

void GetProd (int a[], int b[], int c[], int n)
{
    int N = 1;
    while (N <= 2 * n) N <<= 1;
    for (int i=0; (1<<i) < N; i++)
        for (int j=0; j<N; j++)
            rev[j] = ((rev[j] << 1) | ((j >> i) & 1));
    comp dfa[N], dfb[3][N], aux[N];
    for (int i=0; i<N; i++)
        c[i] = 0;
    for (int i=0; i<3; i++)
    {
        for (int j=0; j<N; j++)
            dfb[i][j] = comp (b[j] % Konst), b[j] /= Konst;
        DFT (dfb[i], N, 0);
    }
    int put = 1;
    for (int i=0; i<3; i++)
    {
        for (int j=0; j<N; j++)
            dfa[j] = comp (a[j] % Konst), a[j] /= Konst;
        DFT (dfa, N, 0);
        int aux_put = put;
        for (int j=0; j<3; j++)
        {
            for (int k=0; k<N; k++)
                aux[k] = dfa[k] * dfb[j][k];
            DFT (aux, N, 1);
            for (int k=0; k<N; k++)
            {
                int curr = ((long long) (aux[k].a + 0.5)) % mod;
                c[k] = ((long long) c[k] + 1LL * aux_put * curr) % mod;
            }
            aux_put = (1LL * aux_put * Konst) % mod;
        }
        put = (1LL * put * Konst) % mod;
    }
}

void dfs (int nod, int tata)
{
    vol[nod] = 1;
    for (auto it = v[nod].begin (); it != v[nod].end (); it ++)
        if (*it != tata)
            dfs (*it, nod), vol[nod] += vol[*it], ap[vol[*it]] ++;
    ap[N - vol[nod]] ++;
}

int pow (int a, int b, int mod)
{
    int p = 1;
    for (int i=0; (1 << i) <= b; i++)
    {
        if (b & (1 << i)) p = (1LL * p * a) % mod;
        a = (1LL * a * a) % mod;
    }
    return p;
}

int comb (int N, int K)
{
    if (K > N || K < 0 || N < 0) return 0;
    int ans = (1LL * fac[N] * inv[K]) % mod;
    ans = (1LL * ans * inv[N - K]) % mod;
    return ans;
}

int main ()
{
//freopen ("input", "r", stdin);
//freopen ("output", "w", stdout);

scanf ("%d", &N), mod = 924844033;
for (int i=1; i<N; i++)
{
    int x, y;
    scanf ("%d %d", &x, &y);
    v[x].push_back (y);
    v[y].push_back (x);
}
dfs (1, -1), fac[0] = 1;
for (int i=1; i<=N; i++)
    fac[i] = (1LL * fac[i - 1] * i) % mod;
inv[N] = pow (fac[N], mod - 2, mod);
for (int i=N - 1; i>=0; i--)
    inv[i] = (1LL * inv[i + 1] * (i + 1)) % mod;
///ans[k] = suma de ap[i] * comb (i, k)
///ans[k] = suma de ap[i] * fac[i] * inv[k] * inv[i - k]
///ans[k] = inv[k] * suma de (ap[i] * fac[i]) * inv[i - k] pentru i de la k la N, i de la 1 la N
///fie sirul inv2[j] = inv2[N - j] -> inv[i - k] = inv2[N - i + k]
///ans[k] = inv[k] * suma de (ap[i] * fac[i]) * inv2[N - i + k]
///ans[k] = inv[k] * pol_result[N + k], definite pana la 2N
ap[0] = 0;
for (int i=0; i<=N; i++)
{
    first_term[i] = (1LL * ap[i] * fac[i]) % mod;
    second_term[i] = inv[N - i];
}
GetProd (first_term, second_term, pol_result, N);
for (int i=1; i<=N; i++)
    ans[i] = (1LL * inv[i] * pol_result[N + i]) % mod;
/*for (int i=1; i<=N; i++)
    printf ("%d\n", ans[i]);
printf ("\n");*/
for (int i=1; i<=N; i++)
{
    ans[i] = ((long long) 1LL * N * comb (N, i) - ans[i]) % mod;
    if (ans[i] < 0) ans[i] += mod;
    printf ("%d\n", ans[i]);
}
return 0;
}


Measured memory_bytes: 66176