#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll mod = 924844033;
const int maxn = 4e5 + 10;
ll fac[maxn], inv[maxn], facinv[maxn], bin[maxn];
void pre()
{
	fac[0] = 1; for(int i = 1; i < maxn; ++i) fac[i] = fac[i - 1] * i % mod;
	inv[1] = 1; for(int i = 2; i < maxn; ++i) inv[i] = (mod - mod / i) * inv[mod % i] % mod;
	facinv[0] = 1; for(int i = 1; i < maxn; ++i) facinv[i] = facinv[i - 1] * inv[i] % mod;
	bin[0] = 1; for(int i = 1; i < maxn; ++i) bin[i] = bin[i - 1] * 2 % mod;
}
ll C(int n, int m) { return n < m ? 0 : fac[n] * facinv[m] % mod * facinv[n - m] % mod;} 
typedef vector <ll> poly;

namespace Poly {
    const int L = 1 << 20;
    const ll P = mod;

    int lim, pos[L];

	inline void deb(poly c) {
        for (int i = 0; i < (int)c.size(); i++)
            printf("%lld%c", c[i], " \n"[i == (int)c.size() - 1]);
    }
    
    inline ll fpow(ll x, ll y) {
        ll res = 1;
        for (; y > 0; y >>= 1) {
            if (y & 1) res = res * x % P;
            x = x * x % P;
        }
        return res;
    }
    
    const ll inv2 = fpow(2, P - 2);

    template <typename T>
    inline void inc(T &x, T y) {
        x += y;
        if (x >= P) x -= P;
    }

    template <typename T>
    inline void sub(T &x, T y) {
        x -= y;
        if (x < 0) x += P;
    }

    inline void prework(int len) {
        int l = 0;
        for (lim = 1; lim < len; lim <<= 1, ++l);
        for (int i = 0; i < lim; i++)
            pos[i] = (pos[i >> 1] >> 1) | ((i & 1) << (l - 1));
    }

    inline void ntt(poly &c, int opt) {
        c.resize(lim, 0);
        for (int i = 0; i < lim; i++)
            if (i < pos[i]) swap(c[i], c[pos[i]]);
        for (int i = 1; i < lim; i <<= 1) {
            ll wn = fpow(5, (P - 1) / (i << 1));
            if (opt == -1) wn = fpow(wn, P - 2);
            for (int len = i << 1, j = 0; j < lim; j += len) {
                ll w = 1;
                for (int k = 0; k < i; k++, w = w * wn % P) {
                    ll x = c[j + k], y = w * c[j + k + i] % P;
                    c[j + k] = (x + y) % P, c[j + k + i] = (x - y + P) % P;
                }
            }
        }

        if (opt == -1) {
            ll inv = fpow(lim, P - 2);
            for (int i = 0; i < lim; i++) c[i] = c[i] * inv % P;
        }
    }

    inline poly operator * (const poly &x, const poly &y) {
        poly res, u = x, v = y;
        prework(u.size() + v.size() - 1);
        ntt(u, 1), ntt(v, 1);
        for (int i = 0; i < lim; i++) res.push_back(v[i] * u[i] % P);
        ntt(res, -1);
        res.resize(u.size() + v.size() - 1);
        return res;
    }
    
    poly mul(const poly & x, const poly & y) {
		return x * y;
	}

    poly getInv(poly x, int len) {
        x.resize(len);
        if (len == 1) {
            poly res;
            res.push_back(fpow(x[0], P - 2));
            return res;
        }
        poly y = getInv(x, (len + 1) >> 1);
        prework(len << 1);

        poly u = x, v = y, res;
        ntt(u, 1), ntt(v, 1);
        for (int i = 0; i < lim; i++) res.push_back(v[i] * (2LL - u[i] * v[i] % P + P) % P);
        ntt(res, -1);

        res.resize(len);
        return res;
    }

    inline void direv(poly &c) {
        for (int i = 0; i < (int)c.size() - 1; i++)
            c[i] = c[i + 1] * (i + 1) % P;
        c[c.size() - 1] = 0;
    }

    inline void integ(poly &c) {
        for (int i = (int)c.size() - 1; i > 0; i--)
            c[i] = c[i - 1] * fpow(i, P - 2) % P;
        c[0] = 0;
    }

    inline poly getLn(poly c) {
        poly a = getInv(c, (int)c.size());
        poly b = c;
        direv(b);

        poly res = b * a;
        res.resize(c.size());
        integ(res);
        return res;
    }
    
    poly getSqrt(poly x, int len) {
        x.resize(len);
        if (len == 1) {
            poly res;
            res.push_back(sqrt(x[0]));
            return res;
        }
        poly y = getSqrt(x, (len + 1) >> 1);
        poly u = x, v = y, w, res;
        w = getInv(y, len);
        
        prework(len << 1);
        ntt(u, 1), ntt(v, 1), ntt(w, 1);
        for (int i = 0; i < lim; i++) 
            res.push_back((v[i] * v[i] % P + u[i]) % P * w[i] % P * inv2 % P);
        ntt(res, -1);
        res.resize(len);
        
        return res;
    }
        
    poly getExp(poly x, int len) {
        x.resize(len, 0);
        if (len == 1) {
            poly res;
            res.push_back(1);
            return res;
        }
        
        poly y = getExp(x, (len + 1) >> 1);
        poly u = x, v = y, w = y, res;
        w.resize(len, 0);
        w = getLn(w);
        
        prework(len << 1);
        u[0] = (u[0] + 1 - w[0] + P) % P;
        for (int i = 1; i < (int)u.size(); i++) u[i] = (u[i] - w[i] + P) % P;
        
        ntt(u, 1), ntt(v, 1);
        for (int i = 0; i < lim; i++) res.push_back(u[i] * v[i] % P);
        ntt(res, -1);
        
        res.resize(len);
        return res;
    }
    
    inline poly fpow(poly x, ll y, int n) {
        x = getLn(x);
        for (int i = 0; i < n; i++) x[i] = x[i] * y % P;
        x = getExp(x, n);
        return x;
    }
    
    inline poly getDiv(poly x, poly y) {
        poly u = x, v = y, res;
        
        reverse(u.begin(), u.end());
        reverse(v.begin(), v.end());    
        
        int len = x.size() - y.size() + 1;
        u.resize(len, 0), v.resize(len, 0);
        
        res = getInv(v, len);
        
        res = mul(u, res);
        res.resize(len);
        
        reverse(res.begin(), res.end());
        
        return res;
    }
    
    inline poly getRest(poly x, poly y) {
        poly u = x, v = y, res = getDiv(x, y);
        
        v = mul(v, res);
        res = u;
        int len = max(u.size(), v.size());
        res.resize(len, 0), v.resize(len, 0);
        for (int i = 0; i < len; i++) res[i] = (res[i] - v[i] + P) % P;
        
        for (; !res.empty() && !res[res.size() - 1]; res.pop_back());
        return res;
    }

}
int n;
int cnt[maxn];
vector<int> E[maxn];
int dfs(int x, int fa)
{
	int ret = 1;
	for(auto v : E[x])
		if(v != fa)
		{
			int cur = dfs(v, x);
			++cnt[cur];
			ret += cur;
		}
	++cnt[n - ret];
	return ret;
}
int main()
{
	pre();
	scanf("%d", &n);
	for(int i = 1; i < n; ++i) 
	{
		int u, v;
		scanf("%d%d", &u, &v);
		E[u].push_back(v);
		E[v].push_back(u);
	}
	dfs(1, 0);
	poly A(n + 1), B(n + 1);
	for(int i = 0; i <= n; ++i) A[i] = fac[i] * cnt[i] % mod;
	for(int i = 0; i <= n; ++i) B[n - i] = facinv[i];
	poly ret = Poly::mul(A, B);
	for(int i = 1; i <= n; ++i)
	{
		ll ans = n * C(n, i) % mod;
		ans -= facinv[i] * ret[n + i] % mod;
		ans = (ans % mod + mod) % mod;
		printf("%lld\n", ans);
	}
	return 0;
}
	

Measured memory_bytes: 70316