// Slower C++ solution:
#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;

}

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

#include<iostream>

#include<cstring>

#include<algorithm>



#define N 600050

#define LL long long

const int mod=924844033,G1=5,G2=(3ll*mod+1)/G1;

using namespace std;

int n;

int he[N],ne[N<<2],to[N<<2],tot;

inline void addedge(int x,int y){

	to[++tot]=y;ne[tot]=he[x];he[x]=tot;

}

inline int qpow(int d,int z){

	int ret=1;

	for(;z;z>>=1,d=1ll*d*d%mod)

		if(z&1)ret=1ll*ret*d%mod;

	return ret;

}

int inc[N],inv[N];

inline int C(int n,int m){

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

}

inline void init(int n){

	inc[0]=inv[0]=1;

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

	inv[n]=qpow(inc[n],mod-2);

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

}

int sz[N],a[N],b[N];

inline void dfs(int g,int fa){

	sz[g]=1;

	for(int i=he[g];i;i=ne[i])

		if(to[i]!=fa)dfs(to[i],g),sz[g]+=sz[to[i]];

	if(fa)(a[sz[g]]+=inc[sz[g]])%=mod,(a[n-sz[g]]+=inc[n-sz[g]])%=mod;

}

inline void ntt(int *a,int n,int tag){

	static int r[N],cnt;cnt=-2;

	for(int i=n;i;i>>=1,++cnt);

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

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

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

	}

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

		int u=qpow(tag==1?G1:G2,mod/i/2),w=1;

		for(int j=0,I=i<<1;j<n;j+=I,w=1){

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

				int t=1ll*w*a[j+k+i]%mod;

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

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

			}

		}

	}

	if(tag==1)return;

	const LL iv=qpow(n,mod-2);

	for(int i=0;i<n;++i)a[i]=iv*a[i]%mod;

}



int main(){

	cin>>n;init(n+n);

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

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

	dfs(1,0);

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

	int len=1;while(len<=n)len<<=1;len<<=1;

	ntt(a,len,1);ntt(b,len,1);

	for(int i=0;i<len;++i)a[i]=1ll*a[i]*b[i]%mod;

	ntt(a,len,-1);

	for(int i=1;i<=n;++i)a[i]=a[i+n];

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

		a[i]=1ll*inv[i]*(1ll*inc[n]*inv[n-i]%mod*n%mod+mod-a[i])%mod;

		printf("%d\n",(a[i])%mod);

	}

	return 0;

}