#include<cstdio>
#include<algorithm>

using int64=long long;
using uchar=unsigned char;

constexpr int maxn(200000);
constexpr int mxdg(524288);
constexpr int p(924844033);
constexpr int proot(5);

namespace math_template{
	template<class _Tp>
		inline void swap(_Tp&x,_Tp&y)
			{_Tp z=x;x=y;y=z;}

	template<class _Tp>
		inline int fpow(_Tp v,int n){
			int pw=1;
			for(;n;n>>=1,v=(int64)v*v%p)
				if(n&1)pw=(int64)pw*v%p;
			return pw;
		}

	template<class x_tp,class y_tp>
		inline void inc(x_tp&x,const y_tp&y)
			{(p-y<=x)?(x+=y-p):(x+=y);}
	template<class x_tp,class y_tp>
		inline void dec(x_tp&x,const y_tp&y)
			{x-=y;(x<0)&&(x+=p);}

	template<class x_tp,class y_tp>
		inline x_tp pls(const x_tp&x,const y_tp&y)
			{return(x<p-y)?(x+y):(x-p+y);}
	template<class x_tp,class y_tp>
		inline x_tp sub(const x_tp&x,const y_tp&y)
			{return(x<y)?(x-y+p):(x-y);}

	template<class _Tp>
		inline int sqr(const _Tp&v)
			{return(int64)v*v%p;}
}

namespace IOManager{
	constexpr int FILESZ(131072);
	char buf[FILESZ];
	const char *ibuf(buf),*tbuf(buf);

	struct IOManager{
		inline char gc()
			{return(ibuf==tbuf)&&(tbuf=(ibuf=buf)+fread(buf,1,FILESZ,stdin),ibuf==tbuf)?EOF:*ibuf++;}
		template<class _Tp>
			inline operator _Tp(){
				_Tp s=0;char c=gc();
				for(;c<48;c=gc());
				for(;47<c;c=gc())
					s=s*10+c-48;
				return s;
			}
	};
}IOManager::IOManager io;

namespace poly{
	using namespace math_template;

	using poly_t=int[mxdg];
	using poly=int*const;

	inline int calcpw2(const int&n){
		int t=1;
		for(;t<n;t<<=1);
		return t;
	}

	int wn[mxdg],
		iwn[mxdg];

	inline void polyinit(){
		const int wnv=fpow(proot,(p-1)/mxdg);
		const int iwnv=fpow(wnv,p-2);
		wn[0]=iwn[0]=1;
		for(int i=1,v=1,iv=1;i!=mxdg;++i){
			v=(int64)v*wnv%p;wn[i]=v;
			iv=(int64)iv*iwnv%p;iwn[i]=iv;
		}
	}

	void DFT(poly&A,const int&deg){
		for(int i=0,j=0;i!=deg;++i){
			if(i<j)swap(A[i],A[j]);
			for(int k=deg>>1;(j^=k)<k;k>>=1);
		}
		int*const td=A+deg;
		for(int l=1,tp=mxdg>>1;l!=deg;l+=l,tp>>=1)
			for(int*i=A,z;i<td;i+=l+l)
				for(int j=0,*w=wn;j!=l;++j,w+=tp)
					z=(int64)i[j+l]**w%p,
					i[j+l]=sub(i[j],z),
					inc(i[j],z);
	}
	void IDFT(poly&A,const int&deg){
		for(int i=0,j=0;i!=deg;++i){
			if(i<j)swap(A[i],A[j]);
			for(int k=deg>>1;(j^=k)<k;k>>=1);
		}
		int*const td=A+deg;
		for(int l=1,tp=mxdg>>1;l!=deg;l+=l,tp>>=1)
			for(int*i=A,z;i<td;i+=l+l)
				for(int j=0,*w=iwn;j!=l;++j,w+=tp)
					z=(int64)i[j+l]**w%p,
					i[j+l]=sub(i[j],z),
					inc(i[j],z);
	}
}

struct Edge{
	int v;Edge*las;
	inline Edge* init(const int&to,Edge*const&ls)
		{return v=to,las=ls,this;}
}*las[maxn+1];

inline void AddEdge(){
	static Edge pool[maxn<<1],*alc=pool-1;
	const int u=io,v=io;
	las[u]=(++alc)->init(v,las[u]);
	las[v]=(++alc)->init(u,las[v]);
}

int sz[maxn+1],
	cnt[maxn+1];

void precalc(const int&u,const int&fa){
	sz[u]=1;
	for(Edge*o=las[u];o;o=o->las)
		if(o->v!=fa)
			precalc(o->v,u),
			sz[u]+=sz[o->v];
}

int Fac[maxn+1],
	invFac[maxn+1];

inline int C(const int&n,const int&k)
	{return(int64)Fac[n]*invFac[k]%p*invFac[n-k]%p;}

using namespace poly;

poly_t f,g;

int main(){
	polyinit();

	const int n=io;
	for(int i=n-1;i!=0;--i)
		AddEdge();

	precalc(1,0);
	for(int i=2;i<=n;++i)
		++cnt[sz[i]],
		++cnt[n-sz[i]];

	int v=1;
	Fac[0]=Fac[1]=invFac[0]=invFac[1]=1;
	for(int i=2;i<=n;++i)
		v=(int64)v*i%p,
		Fac[i]=v;
	v=fpow(v,p-2);
	for(int i=n;i!=1;--i)
		invFac[i]=v,
		v=(int64)v*i%p;

	for(int i=1;i<=n;++i)
		f[i]=(int64)cnt[i]*Fac[i]%p;
	std::reverse_copy(invFac,invFac+n+1,g);

	const int deg(calcpw2(n+n)),invdeg(fpow(deg,p-2));

	DFT(f,deg);DFT(g,deg);
	for(int i=0;i!=deg;++i)
		f[i]=(int64)f[i]*g[i]%p;
	IDFT(f,deg);

	for(int i=1;i<=n;++i)
		printf("%d\n",sub((int64)n*C(n,i)%p,(int64)f[n+i]*invdeg%p*invFac[i]%p));

	return 0;
}

Measured memory_bytes: 26624