// Slower C++ solution:
#include <bits/stdc++.h>

typedef long long ll;



const int N = 2e5+50;

const int P = 924844033;



struct Graph {

	struct Edge {

		int to, nxt;

	} e[N<<1];

	int top, head[N];

	

	Graph(): top(0) {

		memset(head, -1, sizeof head);

	}

	

	void add(int u, int v) {

		e[top] = (Edge){v, head[u]};

		head[u] = top++;

	}

	

	void add2(int u, int v) {

		add(u, v);

		add(v, u);

	}

} G;



int n, a[N];

int siz[N];

int fac[N], ifac[N];

int g[N], h[N], s[N<<1];



int qPow(int x, int k) {

	int rtn = 1;

	for (; k; k >>= 1, x = (ll)x * x % P)

		if (k & 1) rtn = (ll)rtn * x % P;

	return rtn;

}



void dfs(int u, int fa) {

	siz[u] = 1;

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

		int v = G.e[i].to;

		if (v == fa) continue;

		dfs(v, u);

		siz[u] += siz[v];

		a[siz[v]]--;

	}

	a[n]++;

	a[n-siz[u]]--;

}



void initFac() {

	fac[0] = 1;

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

		fac[i] = (ll)fac[i-1] * i % P;

	ifac[n] = qPow(fac[n], P-2);

	for (int i = n-1; i >= 0; i--)

		ifac[i] = (ll)ifac[i+1] * (i+1) % P;

}



namespace NTT {

	const int G = 5;

	

	int n;

	int rev[N<<2];

	int a[N<<2], b[N<<2], t[N<<2];

	

	void init(int m) {

		int len = 0;

		for (n = 1; n < m; n <<= 1)

			len++;

		for (int i = 0; i < n; i++)

			rev[i] = rev[i>>1] >> 1 | (i&1) << len-1;

	}

	

	void NTT(int f[], int sgn) {

		for (int i = 0; i < n; i++)

			if (rev[i] > i) std::swap(f[rev[i]], f[i]);

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

			int gn = qPow(G, (P-1)/(i*2));

			if (sgn == -1) gn = qPow(gn, P-2);

			for (int j = 0; j < n; j += i*2) {

				int g = 1;

				for (int k = 0; k < i; k++, g = (ll)g * gn % P) {

					int x = f[j+k], y = (ll)g * f[j+i+k] % P;

					f[j+k] = (x + y) % P;

					f[j+i+k] = (x - y) % P;

				}

			}

		}

		if (sgn == -1) {

			int invn = qPow(n, P-2);

			for (int i = 0; i < n; i++)

				f[i] = (ll)f[i] * invn % P;

		}

		for (int i = 0; i < n; i++)

			f[i] = (f[i] + P) % P;

	}

	

	void mul(int la, int ta[], int lb, int tb[], int res[]) {

		init(la+lb-1);

		memset(a, 0, sizeof a);

		memset(b, 0, sizeof b);

		for (int i = 0; i < la; i++)

			a[i] = ta[i];

		for (int i = 0; i < lb; i++)

			b[i] = tb[i];

		NTT(a, 1);

		NTT(b, 1);

		for (int i = 0; i < n; i++)

			t[i] = (ll)a[i] * b[i] % P;

		NTT(t, -1);

		for (int i = 0; i < la+lb-1; i++)

			res[i] = t[i];

	}

}



int main() {

	scanf("%d", &n);

	initFac();

	for (int i = 1, u, v; i < n; i++) {

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

		G.add2(u, v);

	}

	dfs(1, 0);

	for (int i = 0; i < n; i++) {

		g[i] = ifac[i];

		h[i] = (ll)fac[n-i] * a[n-i] % P;

	}

	NTT::init(n);

	NTT::mul(n, g, n, h, s);

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

		printf("%d\n", (int)((ll)s[n-i] * ifac[i] % P));

	return 0;

}


// Faster C++ solution for the same problem (measured speedup: 8.432681978186434x):
#include<iostream>

#include<cstdio>

#include<cstdlib>

#include<cstring>

#include<string>

#include<algorithm>

#include<math.h>

using namespace std;



const int N=2e5+5;

const int M=5e5+5;

const int T=1e6+5;

const int mod=924844033;

const int sqr=5;

const int sqrinv=554906420;



int n,u,v,siz[N],limit,lg;

int E,ot[M],ne[M],g[N];

int fac[N],inv[N],infac[N];

int a[T],b[T],r[T];



int F_p(int x,int y)

{

    int bas=x,ret=1;

    while(y)

    {

        if(y&1) ret=1LL*ret*bas%mod;

        bas=1LL*bas*bas%mod;

        y>>=1;

    }

    return ret;

}



void add(int u,int v)

{

    ot[++E]=v;

    ne[E]=g[u];

    g[u]=E;

}



void init()

{

    int i;

    scanf("%d",&n);

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

    {

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

        add(u,v),add(v,u);

    }

}



void dfs(int x,int fath)

{

    siz[x]=1;

    int p,to;

    for(p=g[x];p;p=ne[p])

    {

        to=ot[p];

        if(to==fath) continue;

        dfs(to,x);

        siz[x]+=siz[to];

        ++a[siz[to]];

    }

    ++a[n-siz[x]];

}



int solve_complex(int x,int tp)

{

    if(~tp) return F_p(sqr,x);

    else return F_p(sqrinv,x);

}



void DFT(int *A,int tp)

{

    int i;

    for(i=0;i<limit;++i)

        if(i<r[i])

            swap(A[i],A[r[i]]);



    int len,j,k;

    for(len=1;len<limit;len<<=1)

    {

        int wn=solve_complex((mod-1)/(2*len),tp);

        for(j=0;j<limit;j+=len<<1)

        {

            int w=1;

            for(k=0;k<len;++k,w=1LL*w*wn%mod)

            {

                int x=A[j+k];

                int y=1LL*w*A[j+k+len]%mod;

                A[j+k]=x+y,A[j+k+len]=x-y;

                if(A[j+k]>=mod) A[j+k]-=mod;

                if(A[j+k+len]<0) A[j+k+len]+=mod;

            }

        }

    }

}



void prework()

{

    int i;dfs(1,0);

    fac[0]=1;for(i=1;i<=n;++i) fac[i]=1LL*fac[i-1]*i%mod;

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

    infac[0]=1;for(i=1;i<=n;++i) infac[i]=1LL*infac[i-1]*inv[i]%mod;

}



void work()

{

    int i;a[0]=0;

    for(i=0;i<=n;++i) a[i]=1LL*a[i]*fac[i]%mod;

    for(i=0;i<=n;++i) b[i]=infac[n-i];



    limit=1;

    while(limit<=2*n) limit<<=1,++lg;

    for(i=1;i<limit;++i) r[i]=(r[i>>1]>>1)|((i&1)<<(lg-1));



    DFT(a,1),DFT(b,1);

    for(i=0;i<limit;++i) a[i]=1LL*a[i]*b[i]%mod;

    DFT(a,-1);



    int INV=F_p(limit,mod-2);

    for(i=1;i<=n;++i) a[i+n]=1LL*a[i+n]*INV%mod*infac[i]%mod;

    for(i=1;i<=n;++i) a[i]=1LL*fac[n]*infac[i]%mod*infac[n-i]%mod*n%mod;

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

    {

        a[i]-=a[i+n];

        if(a[i]<0) a[i]+=mod;

    }

    for(i=1;i<=n;++i) printf("%d\n",a[i]);

}



int main()

{

    init();prework();work();

    return 0;

}