// Original C++ solution (slower):
#include <bits/stdc++.h>

#define rep(i, n) for(int i = 0; i < (int)(n); i ++)

#define rep1(i, n) for(int i = 1; i <= (int)(n); i ++)

#define MP make_pair



using namespace std;

typedef long long LL;

typedef pair<int, int> PII;

const int MOD = 924844033;

const int PRT = 5;



int power(int x, int t)

{

	int ret = 1;

	while(t > 0) {

		if(t & 1) ret = 1LL * ret * x % MOD;

		x = 1LL * x * x % MOD;

		t >>= 1;

	}

	return ret;

}



void DFT(int from[], int to[], int len, int dir)

{

	int cur = 0;

	rep(i, 1 << len) {

		to[cur] = from[i];

		for(int j = len - 1; j >= 0; j --) {

			cur ^= 1 << j;

			if((cur >> j) & 1) break;

		}

	}

	

	for(int d = 2; d <= (1 << len); d <<= 1) {

		int cr = power(PRT, MOD - 1 + (MOD - 1) / d * dir);

		for(int i = 0; i < (1 << len); i += d) {

			int rt = 1;

			for(int j = i; j < i + (d >> 1); j ++) {

				int ev = to[j], od = 1LL * to[j + (d >> 1)] * rt % MOD;

				to[j] = (ev + od) % MOD;

				to[j + (d >> 1)] = (ev - od + MOD) % MOD;

				rt = 1LL * rt * cr % MOD;

			}

		}

	}

	

	if(dir < 0) {

		int gr = power(1 << len, MOD - 2);

		rep(i, 1 << len) to[i] = 1LL * to[i] * gr % MOD;

	}

}



int _u[524288], _v[524288], _w[524288];

void poly_mul(int p0[], int p1[], int ret[], int n)

{

	int cl = 0;

	while((1 << cl) <= n) cl ++;

	cl ++;

	

	rep(i, 1 << cl) {

		_u[i] = i <= n ? p0[i] : 0;

		_v[i] = i <= n ? p1[i] : 0;

	}

	DFT(_u, _w, cl, 1);

	DFT(_v, _u, cl, 1);

	rep(i, 1 << cl) _v[i] = 1LL * _u[i] * _w[i] % MOD;

	DFT(_v, _w, cl, -1);

	

	for(int i = 0; i <= 2 * n; i ++) ret[i] = _w[i];

}



int inv[200005];

int fac[200005], ifac[200005];

void gen_fac(int n)

{

	inv[1] = 1;

	for(int i = 2; i <= n; i ++) inv[i] = MOD - 1LL * inv[MOD % i] * (MOD / i) % MOD;

	

	fac[0] = ifac[0] = 1;

	rep1(i, n) {

		fac[i] = 1LL * fac[i - 1] * i % MOD;

		ifac[i] = 1LL * ifac[i - 1] * inv[i] % MOD;

	}

}



int n;

vector<int> G[200005];



int sz[200005];

void dfs(int v, int par)

{

	sz[v] = 1;

	rep(i, G[v].size()) {

		int u = G[v][i];

		if(u == par) continue;

		dfs(u, v);

		sz[v] += sz[u];

	}

}



int poly0[400005], poly1[400005], poly2[400005];



int main()

{

	scanf("%d", &n);

	rep(i, n - 1) {

		int u, v;

		scanf("%d%d", &u, &v);

		G[u].push_back(v);

		G[v].push_back(u);

	}

	dfs(1, -1);

	

	poly0[n] = n;

	rep1(i, n) rep(j, G[i].size()) {

		int nj = G[i][j];

		if(sz[nj] > sz[i]) poly0[n - sz[i]] --;

		else poly0[sz[nj]] --;

	}

	

	gen_fac(n);

	rep1(i, n) poly0[i] = 1LL * (MOD + poly0[i]) * fac[i] % MOD;

	for(int i = 0; i <= n; i ++) poly1[i] = ifac[n - i];

	

	poly_mul(poly0, poly1, poly2, n);

	

	rep1(i, n) printf("%d\n", 1LL * poly2[n + i] * ifac[i] % MOD);

	return 0;

}

// Optimized solution to the same problem (faster):
#include <algorithm>

#include <iostream>

#include <cstdlib>

#include <cstring>

#include <cstdio>

#include <vector>

#include <cmath>

#define re register

using namespace std;



inline int read() {

    int X=0,w=1; char c=getchar();

    while (c<'0'||c>'9') { if (c=='-') w=-1; c=getchar(); }

    while (c>='0'&&c<='9') X=X*10+c-'0',c=getchar();

    return X*w;

}



const int N=600000+10;

const int mod=924844033;

inline int qpow(int a,int b) { int c=1;

    for (;b;b>>=1,a=1ll*a*a%mod) if (b&1) c=1ll*c*a%mod;

    return c;

}



int n;



struct edge { int v,nxt; } e[N<<1];

int head[N];

inline void addEdge(int u,int v) {

    static int c=0;

    e[++c]=(edge){v,head[u]},head[u]=c;

}



int fac[N],ifac[N];

inline void init(int n) {

    fac[0]=1;

    for (re int i=1;i<=n;++i) fac[i]=1ll*fac[i-1]*i%mod;

    ifac[n]=qpow(fac[n],mod-2);

    for (re int i=n;i;--i) ifac[i-1]=1ll*ifac[i]*i%mod;

}

inline int C(int n,int m) {

    return 1ll*fac[n]*ifac[m]%mod*ifac[n-m]%mod;

}



int cnt[N],sz[N];

inline void dfs(int u,int fa) {

    sz[u]=1;

    for (re int i=head[u];i;i=e[i].nxt) {

        int v=e[i].v; if (v==fa) continue;

        dfs(v,u),sz[u]+=sz[v],++cnt[sz[v]];

    }

    ++cnt[n-sz[u]];

}



int r[N],F[N],G[N];

inline void NTT(int* A,int n,int op) {

    for (re int i=0;i<n;++i) if (i<r[i]) swap(A[i],A[r[i]]);

    for (re int i=1;i<n;i<<=1) {

        int rot=qpow(op==1?5:554906420,(mod-1)/(i<<1));

        for (re int j=0;j<n;j+=i<<1)

            for (re int k=0,w=1;k<i;++k,w=1ll*w*rot%mod) {

                int x=A[j+k],y=1ll*w*A[j+k+i]%mod;

                A[j+k]=(x+y)%mod,A[j+k+i]=(x-y+mod)%mod;

            }

    }

    if (op==-1) { int inv=qpow(n,mod-2);

        for (re int i=0;i<n;++i) A[i]=1ll*A[i]*inv%mod;

    }

}



int main() {

    n=read();

    for (re int i=1;i<n;++i) {

        int u=read(),v=read();

        addEdge(u,v),addEdge(v,u);

    }

    dfs(1,0); init(n);

    for (re int i=1;i<=n;++i) F[i]=1ll*cnt[i]*fac[i]%mod;

    reverse(F,F+n+1);

    for (re int i=0;i<=n;++i) G[i]=ifac[i];

    int lim=1,l=0;

    for (;lim<=n<<1;lim<<=1,++l);

    for (re int i=0;i<lim;++i) r[i]=(r[i>>1]>>1)|((i&1)<<(l-1));

    NTT(F,lim,1),NTT(G,lim,1);

    for (re int i=0;i<lim;++i) F[i]=1ll*F[i]*G[i]%mod;

    NTT(F,lim,-1);

    reverse(F,F+n+1);

    for (re int i=1;i<=n;++i)

        printf("%lld\n",(1ll*n*C(n,i)%mod

                        -1ll*ifac[i]*F[i]%mod+mod)%mod);

    return 0;

}

// Fastest known solution for this problem: