#pragma GCC optimize("Ofast", "unroll-loops")

#include <bits/stdc++.h>

using namespace std;

#define ll long long

constexpr ll mod = 924844033LL;
constexpr ll root = 5LL;

ll modpow(ll x, ll n){
    if (n == 0) return 1LL;
    ll tmp = modpow(x, n / 2);
    if (n % 2 == 0) return tmp * tmp % mod;
    return tmp * tmp % mod * x % mod;
}

ll inverse(ll x){
    return modpow(x, mod - 2);
}
 
void ntt(vector<ll>& a, bool rev = false){
    const int size = a.size();
    if(size == 1) return;
    vector<ll> b(size);
    ll r = rev ? (mod - 1 - (mod - 1) / size) : (mod - 1) / size;
    ll s = modpow(root, r);
    vector<ll> kp(size / 2 + 1, 1);
    for(int i = 0; i < size / 2; ++i) kp[i + 1] = kp[i] * s % mod;
    for(int i = 1, l = size / 2; i < size; i <<= 1, l >>= 1){
        for(int j = 0, r = 0; j < l; ++j, r += i){
            for(int k = 0, s = kp[i * j]; k < i; ++k){
                ll p = a[k + r], q = a[k + r + size / 2];
                b[k + 2 * r] = (p + q) % mod;
                b[k + 2 * r + i] = ((p - q) % mod + mod) % mod * s % mod;
            }
        }
        swap(a, b);
    }
    if(rev){
        s = inverse(size);
        for(int i = 0; i < size; i++){ a[i] = a[i] * s % mod; }
    }
}
 
vector<ll> convolute(vector<ll>& a, vector<ll>& b){
    const int size = (int)a.size() + (int)b.size() - 1;
    int t = 1;
    while(t < size){ t <<= 1; }
    vector<ll> A(t, 0), B(t, 0);
    for(int i = 0; i < (int)a.size(); i++){ A[i] = a[i]; }
    for(int i = 0; i < (int)b.size(); i++){ B[i] = b[i]; }
    ntt(A), ntt(B);
    for (int i = 0; i < t; i++){ A[i] = A[i] * B[i] % mod; }
    ntt(A, true);
    A.resize(size);
    return A;
}

ll fact(ll k, int sgn = 0) {
	static vector<ll> fac(2, 1LL);
	static vector<ll> inv(2, 1LL);
	static vector<ll> finv(2, 1LL);
	static ll nx = 2LL;
	while (nx <= k) {
		fac.push_back(fac[nx - 1] * nx % mod);
		inv.push_back(mod - inv[mod % nx] * (mod / nx) % mod);
		finv.push_back(finv[nx - 1] * inv[nx] % mod);
		++nx;
	}
	if (sgn == 0)
		return fac[k];
	return finv[k];
}

ll comb(ll a, ll b) {
	if (b < 0 || b > a) return 0;
	return fact(a) * fact(b, 1) % mod * fact(a - b, 1) % mod;
}

int N;
vector<vector<int>> g;

void input(void){
	cin >> N;
	g.resize(N);
	for (int i = 0; i < N - 1; ++i){
		int a, b; cin >> a >> b;
		--a, --b;
		g[a].push_back(b);
		g[b].push_back(a);
	}
}

vector<int> cnt_sub;
vector<ll> c;

void dfs(int s = 0, int p = -1){
	cnt_sub.resize(N);
	c.resize(N + 1, 0);
	int res = 1;
	for (auto child : g[s]){
		if (child != p){
			dfs(child, s);
			res += cnt_sub[child];
			++c[cnt_sub[child]];
		}
	}
	cnt_sub[s] = res;
	if (s != 0) ++c[N - res];
}

int main(void){
	input(); dfs();

	vector<ll> d(N + 1, 0);

	for (int i = 0; i < N; ++i){
		c[i] = c[i] * fact(i) % mod;
		d[N - i] = fact(i, 1);
	}
	d[0] = fact(N, 1);

	vector<ll> tmp = convolute(c, d);

	vector<ll> res(N + 1, 0);
	for (int k = 0; k <= N; ++k){
		res[k] = tmp[N + k] * fact(k, 1) % mod;
	}

	/*
	for (int i = 0; i <= N; ++i)
		cout << c[i] << " ";
	cout << endl;
	for (int i = 0; i <= N; ++i)
		cout << d[i] << " ";
	cout << endl;
	for (int i = 0; i <= N; ++i)
		cout << res[i] << " ";
	cout << endl;
	*/

	for (int k = 0; k <= N; ++k)
		res[k] = ((N * comb(N, k) % mod - res[k]) % mod + mod) % mod;
	
	for (int k = 1; k <= N; ++k)
		cout << res[k] << endl;

	return 0;
}


Measured memory_bytes: 53280