//~ while (clock()<=69*CLOCKS_PER_SEC)
//~ #pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("O3")
//~ #pragma GCC target ("avx2")
//~ #pragma GCC optimize("Ofast")
//~ #pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
//~ #pragma GCC optimize("unroll-loops")
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>

using namespace __gnu_pbds;
using namespace std;

template <typename T>
using ordered_set =
    tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;

#define sim template < class c
#define ris return * this
#define dor > debug & operator <<
#define eni(x) sim > typename \
  enable_if<sizeof dud<c>(0) x 1, debug&>::type operator<<(c i) {
sim > struct rge { c b, e; };
sim > rge<c> range(c i, c j) { return rge<c>{i, j}; }
sim > auto dud(c* x) -> decltype(cerr << *x, 0);
sim > char dud(...);
struct debug {
#ifdef LOCAL
~debug() { cerr << endl; }
eni(!=) cerr << boolalpha << i; ris; }
eni(==) ris << range(begin(i), end(i)); }
sim, class b dor(pair < b, c > d) {
  ris << "(" << d.first << ", " << d.second << ")";
}
sim dor(rge<c> d) {
  *this << "[";
  for (auto it = d.b; it != d.e; ++it)
    *this << ", " + 2 * (it == d.b) << *it;
  ris << "]";
}
#else
sim dor(const c&) { ris; }
#endif
};
#define imie(...) " [" << #__VA_ARGS__ ": " << (__VA_ARGS__) << "] "

#define shandom_ruffle random_shuffle

using ll=long long;
using pii=pair<int,int>;
using pll=pair<ll,ll>;
using vi=vector<int>;
using vll=vector<ll>;
const int nax=207;
const ll mod=998244353;
const ll d=60;

struct MyHash { std::size_t operator()(pll x) const
{
	return x.first^x.second;
} };

int n;

vi graf[nax];

int naj[nax];

ll dp[nax][nax];

pll pus;

int daj(pll v, int kt)
{
	if (kt>=2*d)
		return 0;
	if (kt<d)
		return (v.first>>kt)&1;
	return (v.second>>(kt-d))&1;
}

pll zapal(pll v, int kt)
{
	if (kt<d)
		v.first|=(1LL<<kt);
	else
		v.second|=(1LL<<(kt-d));
	return v;
}

pll zeruj_nad(pll v, int x)//usuwa wlacznie z x
{
	if (x<d)
	{
		v.second=0;
		v.first&=(1LL<<x)-1;
	}
	else
	{
		v.second&=(1LL<<(x-d))-1;
	}
	return v;
}

int najwiekszy(pll v)
{
	if (v.second)
		return d+(63-__builtin_clz(v.second));
	return (63-__builtin_clz(v.first));
}

int czylisc(int v)
{
	return graf[v].empty();
}

int moge(int v, int co)
{
	vi wek(co);
	for (int i : graf[v])
		wek[min(naj[i], co-1)]++;
	for (int i=co-1; i; i--)
	{
		if (wek[i]>1)
		{
			wek[i-1]+=wek[i]-1;
			wek[i]=1;
		}
	}
	for (int i : wek)
		if (!i)
			return 0;
	return 1;
}

void dfs0(int v, int oj)
{
	for (int &i : graf[v])
	{
		if (i==oj)
		{
			swap(i, graf[v].back());
			graf[v].pop_back();
			break;
		}
	}
	for (int i : graf[v])
		dfs0(i, v);
	
	if (czylisc(v))
	{
		naj[v]=n;
	}
	else
	{
		while(moge(v, naj[v]+1))
			naj[v]++;
	}
}

ll dppom[nax][nax];//iloma, iledziur

void dod(ll &a, ll b)
{
	a=(a+b)%mod;
}

bool mniej(int a, int b)
{
	return naj[a]<naj[b];
}

void dfs1(int v)
{
	if (czylisc(v))
		return;
	for (int i : graf[v])
		dfs1(i);
	unordered_map<pll, ll, MyHash> now, sta;
	int liscie=0;
	now[pus]=1;
	sort(graf[v].begin(), graf[v].end(), mniej);
	vi jeszcze;
	for (int i : graf[v])
		jeszcze.push_back(naj[v]);
	reverse(graf[v].begin(), graf[v].end());
	for (int i : graf[v])
	{
		if (czylisc(i))
		{
			liscie++;
			continue;
		}
		now.swap(sta);
		now.clear();
		for (int j=0; j<=naj[i]; j++)
		{
			int x=min(j, naj[v]+1);
			for (auto l : sta)
				dod(now[zapal(l.first, x)], l.second*dp[i][j]);
		}
		
		for (int j=0; j<(int)jeszcze.size(); j++)
		{
			if (jeszcze[j]==naj[i])
			{
				jeszcze.erase(jeszcze.begin()+j);
				break;
			}
		}
		
		now.swap(sta);
		now.clear();
		for (auto j : sta)
		{
			int x=najwiekszy(j.first);
			int wsk=0;
			for (int l=0; l<x; l++)
			{
				if (!daj(j.first, l))
				{
					if (wsk==(int)jeszcze.size() || jeszcze[wsk]<l)
						x=l;
					wsk++;
				}
			}
			dod(now[zeruj_nad(j.first, x)], j.second);
		}
	}
	for (auto i : now)
	{
		int brak=0;
		for (int j=0; j<=naj[v]; j++)
		{
			if (daj(i.first, j))
				continue;
			dod(dp[v][j], i.second*dppom[liscie][brak]);
			brak++;
		}
	}
}

int main()
{
	scanf("%d", &n);
	for (int i=1; i<n; i++)
	{
		int a, b;
		scanf("%d%d", &a, &b);
		graf[a].push_back(b);
		graf[b].push_back(a);
	}
	dfs0(1, 0);
	dppom[0][0]=1;
	for (int i=1; i<nax; i++)
	{
		dppom[i][0]=dppom[i-1][0]*n%mod;
		for (int j=1; j<=i; j++)
			dppom[i][j]=(dppom[i-1][j-1]*j+dppom[i-1][j]*(n-j))%mod;
	}
	dfs1(1);
	for (int i=0; i<=n; i++)
		printf("%lld\n", dp[1][i]);
	return 0;
}