#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;
}

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);}
};

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

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];
			}
		}
	}
	
	vc<mint> cur;
	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;
		}
		cur.clear();cur.pb(1);
		sort(all(sc));
		int cnt=0;
		for(auto [s,c]:sc){
			if(s<n){
				cur.resize(1<<(s+1));
				per(bit,si(cur)){
					mint w=cur[bit];
					cur[bit]=0;
					rep(i,s+1){
						cur[bit|1<<i]+=w*dp[c][i];
					}
				}
			}else{
				cnt++;
			}
		}
		rep(bit,si(cur)){
			int hall=0;
			rep(i,n+1){
				int z=0;
				if(i<30&&(bit&1<<i))z=1;
				if(z==0){
					dp[v][i]+=buf[cnt][hall]*cur[bit];
					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();
}