//~ 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;
//~ using bn=bitset<nax>;
const ll d=60;

struct bn
{
	ll wek[2];
	bn()
	{
		//~ wek.resize(4);
		for (int i=0; i<2; i++)
			wek[i]=0;
	}
	int daj(int v) const
	{
		return (wek[v/d]>>(v%d))&1;
	}
	void zapal(int v)
	{
		wek[v/d]|=(1LL<<(v%d));
	}
};

struct MyHash { std::size_t operator()(bn x) const
{
	ll ret=0;
	for (int i=0; i<2; i++)
		ret^=x.wek[i];
	return ret;
} };


bool operator==(const bn& a, const bn& b)
{
	for (int i=0; i<2; i++)
		if (a.wek[i]!=b.wek[i])
			return false;
	return true;
}

int n;

vi graf[nax];

int naj[nax];

ll dp[nax][nax];

bn pus;

bool operator <(const bn &a, const bn &b)
{
	//~ return a.wek<b.wek;
	for (int i=0; i<2; i++)
		if (a.wek[i]!=b.wek[i])
			return a.wek[i]<b.wek[i];
	return false;
}

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<bn, ll, MyHash> now, sta;
	int liscie=0;
	now[pus]=1;
	sort(graf[v].begin(), graf[v].end(), mniej);
	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)
			{
				bn trz=l.first;
				trz.zapal(x);
				dod(now[trz], l.second*dp[i][j]);
			}
		}
	}
	for (auto i : now)
	{
		int brak=0;
		for (int j=0; j<=naj[v]; j++)
		{
			if (i.first.daj(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;
}