// Original C++ solution (slower):
#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;

}


// Optimized solution to the same problem (faster):
// luogu-judger-enable-o2

#include<cstdio>

#include<iostream>

using namespace std;



inline int In(){

	char c=getchar(); int x=0,ft=1;

	for(;c<'0'||c>'9';c=getchar()) if(c=='-') ft=-1;

	for(;c>='0'&&c<='9';c=getchar()) x=x*10+c-'0';

	return x*ft;

}



const int N=2e5+5;

int n,h[N],e_tot=0;

struct Edge{

	int to,nex;

	Edge(){}

	Edge(int to,int nex):to(to),nex(nex){}

}e[N<<1];



inline void add(int u,int v){

	e[++e_tot]=Edge(v,h[u]); h[u]=e_tot;

}



int sz[N],cnt[N],fac[N],inv[N];



void dfs(int u,int pre){

	sz[u]=1;

	for(int i=h[u],v;i;i=e[i].nex){

		v=e[i].to; if(v==pre) continue;

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

	}

	if(u!=1) ++cnt[sz[u]],++cnt[n-sz[u]];

}



const int P=924844033;

int L,C,r[N<<2],F[N<<2],G[N<<2],H[N<<2];



inline void Add(int& x,int y){

	x+=y; if(x>=P) x-=P;

}



inline int Mul(int x,int y){

	return 1ll*x*y%P;

}



inline int fpow(int x,int k){

	int res=1;

	for(;k;k>>=1,x=Mul(x,x)) if(k&1) res=Mul(res,x);

	return res;

}



inline void NTT_prepare(int len){

	for(L=1,C=0;L<=len;L<<=1,++C);

	for(int i=0;i<L;++i) r[i]=(r[i>>1]>>1)|((i&1)<<(C-1));

}



void NTT(int* A,int op){

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

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

		int Wn=fpow(5,(P-1)/(i<<1));

		if(op==-1) Wn=fpow(Wn,P-2);

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

			int w=1;

			for(int k=0;k<i;++k,w=Mul(w,Wn)){

				int p=A[j+k],q=Mul(w,A[j+i+k]);

				A[j+k]=(p+q)%P; A[j+i+k]=((p-q)%P+P)%P;

			}

		}

	}

	if(op==-1){

		int inv_L=fpow(L,P-2);

		for(int i=0;i<L;++i) A[i]=Mul(A[i],inv_L);

	}

}



int main(){

	n=In();

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

		u=In(); v=In();

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

	}

	dfs(1,0); fac[0]=inv[0]=inv[1]=1;

	for(int i=1;i<=n;++i) fac[i]=Mul(fac[i-1],i);

	for(int i=2;i<=n;++i) inv[i]=Mul(P-P/i,inv[P%i]);

	for(int i=1;i<=n;++i) inv[i]=Mul(inv[i-1],inv[i]);

	for(int i=0;i<=n;++i) G[i]=Mul(cnt[i],fac[i]);

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

	NTT_prepare(n+n); NTT(G,1); NTT(H,1);

	for(int i=0;i<L;++i) F[i]=Mul(G[i],H[i]); NTT(F,-1);

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

		int res=Mul(n,Mul(fac[n],Mul(inv[i],inv[n-i])));

		Add(res,P-Mul(inv[i],F[n+i])); printf("%d\n",res);

	}

	return 0;

}

// Fastest known solution for this problem: