#include <bits/stdc++.h>
using namespace std;
//#define cerr if (false) cerr
#define db(x) cerr << #x << "=" << x << endl
#define db2(x, y) cerr << #x << "=" << x << "," << #y << "=" << y << endl
#define db3(x, y, z) cerr << #x << "=" << x << "," << #y << "=" << y << "," << #z << "=" << z << endl
#define dbv(v) cerr << #v << "="; for (auto _x : v) cerr << _x << ", "; cerr << endl
#define dba(a, n) cerr << #a << "="; for (int _i = 0; _i < (n); ++_i) cerr << a[_i] << ", "; cerr << endl
template <typename A, typename B>
ostream& operator<<(ostream& os, const pair<A, B>& x) {
	return os << "(" << x.first << "," << x.second << ")";
}
typedef long long ll;
typedef long double ld;
const int MOD = 924844033;
ll modex(ll a, ll p, ll m = MOD) {
	if (!p) return 1;
	if (p & 1) return a * modex(a, p - 1, m) % m;
	ll v = modex(a, p >> 1, m);
	return v * v % m;
}
namespace fft {
#define NTT
const int mod = 924844033; // 2^23 * 119 + 1
const int gen = 5; // ord(3) = 2^23 * 119
vector<int> rev(1, 0), roots; // rev has [base] bits
int base = 0;
void precompute(int nbase) {
	if (nbase <= base) return;
	rev.resize(1 << nbase);
	for (int i = 0; i < (1 << nbase); ++i) {
		rev[i] = rev[i >> 1] >> 1 | ((i & 1) << nbase - 1);
	}
	roots.resize(1 << nbase);
	for (; base < nbase; ++base) {
		int len = 1 << base;
		ll root = modex(gen, (mod - 1) >> base + 1, mod);
		roots[len] = 1;
		for (int i = 1; i < len; ++i) roots[len + i] = roots[len + i - 1] * root % mod;
	}
}
void fft(vector<int>& a) {
	int n = a.size();
	assert((n & (n - 1)) == 0);
	int zeros = __builtin_ctz(n);
	precompute(zeros);
	int shift = base - zeros;
	for (int i = 0; i < n; ++i) {
		if (i < (rev[i] >> shift)) swap(a[i], a[rev[i] >> shift]);
	}
	for (int len = 1; len < n; len <<= 1)
		for (int i = 0; i < n; i += 2 * len)
			for (int j = 0; j < len; ++j) {
				int u = a[i + j], v = (ll)a[i + j + len] * roots[len + j] % mod;
				a[i + j] = u + v >= mod ? u + v - mod : u + v;
				a[i + j + len] = u - v < 0 ? u - v + mod : u - v;
			}
}
vector<int> multiply(vector<int> a, vector<int> b) {
	if (a.empty() || b.empty()) return {};
	int sz = a.size() + b.size() - 1;
	int n = sz == 1 ? 1 : 1 << (32 - __builtin_clz(sz - 1));
	bool eq = (a == b);
	a.resize(n);
	fft(a);
	if (eq) b = a;
	else {
		b.resize(n);
		fft(b);
	}
	ll inv = modex(n, mod - 2, mod);
	for (int i = 0; i < n; ++i) a[i] = (ll)a[i] * b[i] % mod * inv % mod;
	fft(a);
	reverse(a.begin() + 1, a.end());
	a.resize(sz);
	return a;
}
vector<int> multiply(const vector<int>& a, const vector<int>& b, int m) {
	assert(m == mod);
	return multiply(a, b);
}
}; // namespace fft
vector<int> E[200005];
int siz[200005];
vector<int> B;
int n;
void go(int x, int p = -1) {
	siz[x] = 1;
	for (int y : E[x]) {
		if (y == p) continue;
		go(y, x);
		B[siz[y]]++;
		B[n - siz[y]]++;
		siz[x] += siz[y];
	}
}
struct Mint {
	int val;
	Mint() { val = 0; }
	Mint(const ll& x) {
		val = (-MOD <= x && x < MOD) ? x : x % MOD;
		if (val < 0) val += MOD;
	}
	friend bool operator==(const Mint& a, const Mint& b) { return a.val == b.val; }
	friend bool operator!=(const Mint& a, const Mint& b) { return !(a == b); }
	friend bool operator<(const Mint& a, const Mint& b) { return a.val < b.val; }
	Mint& operator+=(const Mint& m) { if ((val += m.val) >= MOD) val -= MOD; return *this; }
	Mint& operator-=(const Mint& m) { if ((val -= m.val) < 0) val += MOD; return *this; }
	Mint& operator*=(const Mint& m) { val = (ll)val * m.val % MOD; return *this; }
	friend Mint modex(Mint a, ll p) {
		assert(p >= 0);
		Mint ans = 1;
		for (; p; p >>= 1, a *= a) if (p & 1) ans *= a;
		return ans;
	}
	Mint& operator/=(const Mint& m) { return *this *= modex(m, MOD - 2); }
	Mint& operator++() { return *this += 1; }
	Mint& operator--() { return *this -= 1; }
	Mint operator++(int) { Mint result(*this); *this += 1; return result; }
	Mint operator--(int) { Mint result(*this); *this -= 1; return result; }
	Mint operator-() const { return Mint(-val); }
	friend Mint operator+(Mint a, const Mint& b) { return a += b; }
	friend Mint operator-(Mint a, const Mint& b) { return a -= b; }
	friend Mint operator*(Mint a, const Mint& b) { return a *= b; }
	friend Mint operator/(Mint a, const Mint& b) { return a /= b; }
	friend ostream& operator<<(ostream& os, const Mint& x) { return os << x.val; }
};
const int MAXN = 200005;
Mint fac[MAXN], invfac[MAXN];
Mint binom(ll a, ll b) {
	if (b < 0) return 0;
	if (b > a) return 0;
	return fac[a] * invfac[b] * invfac[a - b];
}
int main() {
	fac[0] = 1;
	for (int i = 1; i < MAXN; ++i)
		fac[i] = fac[i - 1] * i;
	invfac[MAXN - 1] = 1 / fac[MAXN - 1];
	for (int i = MAXN - 2; i >= 0; --i)
		invfac[i] = invfac[i + 1] * (i + 1);
	scanf("%d", &n);
	B.resize(n + 1);
	for (int i = 1; i < n; ++i) {
		int a, b;
		scanf("%d%d", &a, &b);
		E[a].push_back(b);
		E[b].push_back(a);
	}
	go(1);
	vector<int> A(n + 1);
	for (int i = 0; i <= n; ++i) {
		B[i] = (B[i] * fac[i]).val;
		A[n - i] = invfac[i].val;
	}
	auto C = fft::multiply(A, B);
	for (int k = 1; k <= n; ++k) {
		Mint ans = Mint(n) * binom(n, k) - invfac[k] * C[k + n];
		printf("%d\n", ans.val);
	}
}


Measured memory_bytes: 34676