// Original C++ solution (slower):
#include<cstdio>

#include<cstring>

#include<algorithm>

using namespace std;

namespace io

{

	const int N=1<<20;

	char buf[N],*t1=buf,*t2=buf;

	#ifdef cjy

	#define getc() getchar()

	#else

	#define getc() t1==t2&&(t2=(t1=buf)+fread(buf,1,N,stdin),t1==t2)?EOF:*t1++

	#endif

	inline int read()

	{

		static int an,f;an=0,f=1;

		static char ch;ch=getc();

		while(ch<48||ch>57)ch=='-'?f=-1:0,ch=getc();

		while(ch>=48&&ch<=57)an=(an<<3)+(an<<1)+(ch^48),ch=getc();

		return an*f;

	}

	char buff[N],*T=buff;

	void flush(){fwrite(buff,1,T-buff,stdout);T=buff;}

	inline void putc(char ch){if(T==buff+N)flush();*T++=ch;}

	template<typename o>

	inline void print(o x)

	{

		if(x<0)putc('-'),x=-x;

		if(!x)return putc('0'),void();

		static int st[20],tp;

		while(x)st[++tp]=x%10,x/=10;

		while(tp)putc(st[tp]^48),--tp;

	}

}

using io::read;

using io::putc;

using io::flush;

using io::print;

const int mod=924844033,g=5;

const unsigned long long bigmod=20ull*mod*mod;

inline void add(int &x,int y){(x+=y)>=mod?x-=mod:0;}

inline int pl(int x,int y){return (x+=y)>=mod?x-mod:x;}

int kpow(int a,int b)

{

	int s=1;

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

		if(b&1)s=1ll*s*a%mod;

	return s;

}

namespace poly

{

	/*void findg()

	{

		for(int g=2;;++g)

		{

			bool flag=1;

			for(int i=2;i*i<=mod-1;++i)

				if((mod-1)%i==0&&kpow(g,(mod-1)/i)==1){flag=0;break;}

			if(flag){printf("%d\n",g);return;}

		}

	}*/

	int w[524288];

	void init()

	{

		for(int len=1;len<524288;len<<=1)

		{

			int tmp=kpow(g,(mod-1)/len/2);

			w[len]=1;

			for(int j=1;j<len;++j)w[len+j]=1ll*w[len+j-1]*tmp%mod;

		}

	}

	void ntt(int f[],int opt,int lim)

	{

		static int r[524288],now;

		if(now!=lim)

		{

			now=lim;

			for(int i=1;i<lim;++i)r[i]=(r[i>>1]>>1)|(i&1?lim>>1:0);

		}

		static unsigned long long t[524288];

		for(int i=0;i<lim;++i)t[i]=f[r[i]];

		for(int len=1;len<lim;len<<=1)

		{

			if(len==65536)for(int i=0;i<lim;++i)t[i]%=mod;

			for(int j=0;j<lim;j+=len<<1)

				for(int k=0;k<len;++k)

				{

					const unsigned long long x=t[j+k+len]*w[len+k]%mod;

					t[j+k+len]=t[j+k]+mod-x,t[j+k]+=x;

				}

		}

		for(int i=0;i<lim;++i)f[i]=t[i]%mod;

		if(opt==-1)

		{

			reverse(f+1,f+lim);

			int c=kpow(lim,mod-2);

			for(int i=0;i<lim;++i)f[i]=1ll*f[i]*c%mod;

		}

	}

	void mulT(int a[],int b[],int c[],int na,int nb,int nc)

	{

		if(na<=200)

		{

			static unsigned long long C[210];

			memset(C,0,nc<<3);

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

				for(int j=0;j<=i&&j<nb;++j)

					(C[i-j]+=1ull*a[i]*b[j])>=bigmod?C[i-j]-=bigmod:0;

			for(int i=0;i<nc;++i)c[i]=C[i]%mod;

			return ;

		}

		static int X[524288],Y[524288],lim;

		lim=1;

		while(lim<na||lim<nb+nc-1)lim<<=1;

		memcpy(X,a,na<<2);memcpy(Y,b,nb<<2);

		reverse(X,X+na);

		ntt(X,1,lim),ntt(Y,1,lim);

		for(int i=0;i<lim;++i)X[i]=1ll*X[i]*Y[i]%mod;

		ntt(X,-1,lim);

		reverse(X,X+na);

		memcpy(c,X,nc<<2);

		memset(X,0,lim<<2);memset(Y,0,lim<<2);

	}

}

struct edge

{

	int nxt,to;

}e[400040];

int fac[200020],ifac[200020];

int n,siz[200020],head[200020],num,a[200020],b[200020];

inline void addedge(int from,int to){e[++num]=edge{head[from],to};head[from]=num;}

void dfs(int v,int fa)

{

	siz[v]=1;

	for(int i=head[v],u;i;i=e[i].nxt)

	{

		u=e[i].to;

		if(u==fa)continue;

		dfs(u,v);

		siz[v]+=siz[u];

		++a[siz[u]];

	}

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

}

int main()

{

//	poly::findg();

	poly::init();

	n=read();

	for(int i=1,x,y;i<n;++i)

	{

		x=read(),y=read();

		addedge(x,y),addedge(y,x);

	}

	dfs(1,0);

	fac[0]=1;

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

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

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

	for(int i=0;i<=n;++i)a[i]=1ll*a[i]*fac[i]%mod,b[i]=ifac[i];

	poly::mulT(a,b,a,n+1,n+1,n+1);

	for(int i=1;i<=n;++i)a[i]=(1ll*fac[n]*ifac[i]%mod*ifac[n-i]%mod*n+1ll*(mod-a[i])*ifac[i])%mod,print(a[i]),putc('\n');

	flush();

	return 0;

}

// Optimized solution to the same problem (faster):
#include<bits/stdc++.h>

#define ll long long

using namespace std;

const int N=600010;

const int mod=924844033;

struct node{

	int v,nxt;

}e[N<<1];

int n,cnt=0,head[N],siz[N],cn[N],jc[N],inv[N];

int a[N],b[N],lim=1,l=0,r[N];

void add(int u,int v){

	e[++cnt].v=v;

	e[cnt].nxt=head[u];

	head[u]=cnt;

}

ll poww(ll x,int y){

	ll ans=1;

	while(y){

		if(y&1){

			ans=ans*x%mod;

		}

		x=x*x%mod;

		y>>=1;

	}

	return ans;

}

void dfs(int s,int fa){

	siz[s]=1;

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

		int v=e[i].v;

		if(v==fa) continue;

		dfs(v,s);

		siz[s]+=siz[v];

		++cn[siz[v]];

	}

	++cn[n-siz[s]];

}

int C(int n,int m){

	return 1ll*jc[n]*inv[m]%mod*inv[n-m]%mod;

}

void ntt(int *a,int f){

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

		if(i<r[i]) swap(a[i],a[r[i]]);

	}

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

		int wn=poww(f==1?5:554906420,(mod-1)/(i<<1));

		for(int j=0;j<lim;j+=(i<<1)){

			ll w=1;

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

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

				a[j+k]=(x+y)%mod;

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

			}

		}

	}

	if(f==-1){

		ll inv=poww(lim,mod-2);

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

			a[i]=1ll*a[i]*inv%mod;

		} 

	}

}

int main(){

//	freopen("k.in","r",stdin);

//	freopen("k.out","w",stdout);

	scanf("%d",&n);

	for(int i=1,x,y;i<n;i++){

		scanf("%d%d",&x,&y);

		add(x,y);add(y,x);

	}

	dfs(1,0);

	jc[0]=1;

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

		jc[i]=1ll*jc[i-1]*i%mod;

	}

	inv[n]=poww(jc[n],mod-2);

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

		inv[i]=1ll*inv[i+1]*(i+1)%mod;

	}

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

		a[i]=1ll*cn[i]*jc[i]%mod;

		b[i]=inv[i];

	}

	reverse(a,a+n+1);

	while(lim<=(n<<1)){

		lim<<=1;

		l++;

	}

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

		r[i]=(r[i>>1]>>1)|((i&1)<<(l-1));

	} 

	ntt(a,1);

	ntt(b,1);

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

		a[i]=1ll*a[i]*b[i]%mod;

	}

	ntt(a,-1);

	reverse(a,a+n+1);

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

		printf("%lld\n",(1ll*n*C(n,i)%mod-1ll*inv[i]*a[i]%mod+mod)%mod);

	}

}

// Fastest known solution for this problem: