#ifndef LOCAL
#pragma GCC optimize ("Ofast")
#pragma GCC optimize ("unroll-loops")
#endif
#include <bits/stdc++.h>
using namespace std;

using ll=long long;
//#define int ll

#define rng(i,a,b) for(int i=int(a);i<int(b);i++)
#define rep(i,b) rng(i,0,b)

#define gnr(i,a,b) for(int i=int(b)-1;i>=int(a);i--)
#define per(i,b) gnr(i,0,b)

#define bg begin()
#define ed end()
#define pb push_back
#define eb emplace_back
#define all(x) x.bg,x.ed
#define si(x) int(x.size())

template<class t>using vc=vector<t>;
template<class t>using vvc=vc<vc<t>>;

template<class t,class u>bool chmin(t&a,u b){
	if(a>b){a=b;return true;}
	else return false;
}
template<class t,class u>bool chmax(t&a,u b){
	if(a<b){a=b;return true;}
	else return false;
}

#define a first
#define b second
using pi=pair<int,int>;

bool add(vc<ll>&a,ll x){
	for(auto v:a)chmin(x,x^v);
	if(x)a.pb(x);
	return x;
}

using uint=unsigned;
const uint mod=998244353;
struct mint{
	uint v;
	mint(ll vv=0){s(vv%mod+mod);}
	mint& s(uint vv){
		v=vv<mod?vv:vv-mod;
		return *this;
	}
	mint operator -()const{return mint()-*this;}
	mint& operator+=(const mint&r){return s(v+r.v);}
	mint& operator-=(const mint&r){return s(v+mod-r.v);} 
	mint& operator*=(const mint&r){v=(unsigned ll)v*r.v%mod;return *this;}
	mint& operator/=(const mint&r){return *this*=r.inv();}
	
	mint operator+(const mint&r){return mint(*this)+=r;}
	mint operator-(const mint&r){return mint(*this)-=r;}
	mint operator*(const mint&r){return mint(*this)*=r;}
	mint operator/(const mint&r){return mint(*this)/=r;}
	
	mint pow(ll n)const{
		if(n<0)return inv().pow(-n);
		mint res(1),x(*this);
		while(n){
			if(n&1)res*=x;
			x*=x;
			n>>=1;
		}
		return res;
	}
	mint inv()const{return pow(mod-2);}
	
	bool operator<(mint r)const{return v<r.v;}
};

mint parity(int i){
	return i&1?-1:1;
}

using u128=unsigned __int128;

void slv(){
	int n;cin>>n;
	vvc<int> t(n);
	rep(_,n-1){
		int x,y;cin>>x>>y;
		x--;y--;
		t[x].pb(y);
		t[y].pb(x);
	}
	vvc<mint> dp(n,vc<mint>(n+1));
	vvc<mint> bin(n+1,vc<mint>(n+1));
	bin[0][0]=1;
	rep(i,n+1)rep(j,n+1){
		if(i)bin[i][j]+=bin[i-1][j];
		if(j)bin[i][j]+=bin[i][j-1];
	}
	vvc<mint> buf(n+1);
	rep(cnt,n+1){
		buf[cnt].resize(cnt+1);
		vc<mint> pn(n+1);
		rep(i,n+1)pn[i]=mint(i).pow(cnt);
		rep(hall,cnt+1){
			rep(c,hall+1){
				buf[cnt][hall]+=parity(c)*bin[hall-c][c]*pn[n-c];
			}
		}
	}
	const int Lmax=120;
	
	vc<pair<u128,mint>> cur,nx;
	vc<mint> z;
	
	auto dfs=[&](auto self,int v,int p)->void{
		vc<pi> sc;
		for(auto ch:t[v])if(ch!=p){
			self(self,ch,v);
			int s=0;
			rep(i,n+1)if(dp[ch][i].v)s=i;
			sc.eb(s,ch);
		}
		if(sc.empty()){
			fill(all(dp[v]),1);
			return;
		}
		
		sort(all(sc));
		int cut=0,num=0;
		for(auto&[s,c]:sc){
			if(s<n){
				if(si(sc)<=s){
					rng(i,si(sc)+1,s+1)dp[c][si(sc)]+=dp[c][i];
					s=si(sc);
				}
				num++;
				if(s<25){
					if(num>25||(1LL<<s)<(1LL<<num)*100000)cut=num;
				}
			}
		}
		z.clear();z.pb(1);
		rep(idx,cut){
			auto [s,c]=sc[idx];
			z.resize(1<<(s+1));
			per(bit,si(z)){
				mint w=z[bit];
				z[bit]=0;
				rep(i,s+1){
					z[bit|1<<i]+=w*dp[c][i];
				}
			}
		}
		
		cur.clear();
		rep(bit,si(z))if(z[bit].v)cur.eb(bit,z[bit]);
		int cnt=0;
		rng(idx,cut,si(sc)){
			auto [s,c]=sc[idx];
			if(s<n){
				nx.clear();
				for(auto [bit,val]:cur){
					rep(i,s+1){
						nx.eb(bit|u128(1)<<i,val*dp[c][i]);
					}
				}
				sort(all(nx));
				cur.clear();
				for(auto [bit,val]:nx){
					if(si(cur)&&cur.back().a==bit)cur.back().b+=val;
					else cur.eb(bit,val);
				}
			}else{
				cnt++;
			}
		}
		for(auto [bit,val]:cur){
			int hall=0;
			rep(i,n+1){
				if(i<Lmax&&(bit>>i&1)){//do nothing
				}else{
					dp[v][i]+=buf[cnt][hall]*val;
					hall++;
					if(hall>cnt)break;
				}
			}
		}
	};
	dfs(dfs,0,-1);
	rep(i,n+1)cout<<dp[0][i].v<<endl;
}

signed main(){
	cin.tie(0);
	ios::sync_with_stdio(0);
	
	slv();
}