#include <bits/stdc++.h>
using namespace std;
template <
        int mod,
        int generator
> struct ntt {
        int mul(long long a, long long b){
                return a * b % mod;
        }
        int pwr(int a, int b){
                int r = 1;
                for(; b; b >>= 1, a = mul(a, a))
                        if(b&1)
                                r = mul(r, a);
                return r;
        }
        int root, root_inv, coef2;
        ntt(){
                int c = mod - 1;
                coef2 = 1;
                while(c % 2 == 0){
                        c /= 2;
                        coef2 *= 2;
                }
                root = pwr(generator, c);
                root_inv = pwr(root, mod - 2);
        }
        void transform(vector<int> &a, bool invert){
                int n = a.size();
                for(int i = 1, j = 0; i < n; i++){
                        int bit = n >> 1;
                        for(; j & bit; bit >>= 1)
                                j ^= bit;
                        j ^= bit;
                        if(i < j)
                                swap(a[i], a[j]);
                }
                for(int len = 2; len <= n; len <<= 1){
                        int wlen = invert ? root_inv : root;
                        for(int i = len; i < coef2; i <<= 1)
                                wlen = mul(wlen, wlen);
                        for(int i = 0; i < n; i += len){
                                int w = 1;
                                for(int j = 0; j < len / 2; j++){
                                        int u = a[i + j], v = mul(a[i + j + len / 2], w);
                                        a[i + j] = u + v < mod ? u + v : u + v - mod;
                                        a[i + j + len / 2] = u - v >= 0 ? u - v : u - v + mod;
                                        w = mul(w, wlen);
                                }
                        }
                }
                if(invert){
                        int n_inv = pwr(n, mod - 2);
                        for(int & x : a)
                                x = mul(x, n_inv);
                }
        }
};
namespace modular_space {
	long long mod;
	struct umod {
		long long val;
		umod(): val(0ll){}
		umod(long long x){ x %= mod; if(x < 0) x += mod; val = x; }
		umod& operator += (umod oth){ val += oth.val; if(val >= mod) val -= mod; return *this; }
		umod& operator -= (umod oth){ val -= oth.val; if(val < 0) val += mod; return *this; }
		umod& operator *= (umod oth){ val = val * oth.val % mod; return *this; }
		umod& operator /= (umod oth){ return *this *= oth.inverse(); }
		umod& operator ^= (long long oth){ return *this = pwr(*this, oth); }
		umod operator + (umod oth) const { return umod(*this) += oth; }
	       	umod operator - (umod oth) const { return umod(*this) -= oth; }
		umod operator * (umod oth) const { return umod(*this) *= oth; }
		umod operator / (umod oth) const { return umod(*this) /= oth; }
		umod operator ^ (long long oth) const { return umod(*this) ^= oth; }
		bool operator < (umod oth) const { return val < oth.val; }
		bool operator > (umod oth) const { return val > oth.val; }
		bool operator <= (umod oth) const { return val <= oth.val; }
		bool operator >= (umod oth) const { return val >= oth.val; }
		bool operator == (umod oth) const { return val == oth.val; }
		bool operator != (umod oth) const { return val != oth.val; }
		umod pwr(umod a, long long b) const {
			umod r = 1;
			for(; b; a *= a, b >>= 1)
				if(b&1)
					r *= a;
			return r;
		}
		umod inverse() const {
			long long a = val, b = mod, u = 1, v = 0;
			while(b){
				long long t = a/b;
				a -= t * b; swap(a, b);
				u -= t * v; swap(u, v);
			}
			if(u < 0)
				u += mod;
			return u;
		}
		friend istream& operator >> (istream &is, umod &oth);
		friend ostream& operator << (ostream &os, const umod& oth);
	};
	ostream& operator << (ostream &os, const umod &oth){
		os << oth.val;
		return os;
	}
	istream& operator >> (istream &is, umod &oth){
		long long x; is >> x;
		oth = umod(x);
		return is;
	}
	struct binprime_kit {
		int sz;
		vector<umod> fat, ifat;
		void init(int s){
			sz = s;
			fat.resize(sz + 1);
			ifat.resize(sz + 1);
			fat[0] = 1;
			for(int i = 1; i <= sz; i++) fat[i] = fat[i - 1] * i;
			ifat[sz] = fat[sz] ^ (mod - 2);
			for(int i = sz - 1; i >= 0; i--) ifat[i] = ifat[i + 1] * (i + 1);
		}
		umod coef(int n, int r){
			if(n < r) return 0;
			return fat[n] * (ifat[r] * ifat[n - r]);
		}
	};
};
using U = modular_space::umod;
const int maxn = 200200, mod = 924844033, gen = 5;
vector<int> to[maxn];
int cnt[maxn], sz[maxn], n;
void dfs(int u, int v){
	sz[u] = 1;
	for(int nxt : to[u]){
		if(nxt == v) continue;
		dfs(nxt, u);
		cnt[sz[nxt]]++;
		sz[u] += sz[nxt];
	}
	if(v != -1){
		cnt[n - sz[u]]++;
	}
}
int main(){
	modular_space::mod = mod;
	modular_space::binprime_kit kit; kit.init(maxn * 8);
	ntt<mod, gen> transform;
	cin >> n;
	for(int i = 0; i < n - 1; i++){
		int u, v; cin >> u >> v;
		to[u].push_back(v);
		to[v].push_back(u);
	}
	dfs(1, -1);
	/**
	     x
	     a[x] = 1
	     b[k - x] = 1 / (-k + x)!
	     k! (x - k)!
	  **/
	int pw = 1;
	while(pw < 4 * n) pw <<= 1;
	int half = pw / 4;
	vector<int> a(pw, 0), b(pw, 0);
	for(int i = 0; i <= n; i++) a[i] = (kit.fat[i] * cnt[i]).val;
	for(int i = 0; i <= n; i++) b[half - i] = kit.ifat[i].val;
	transform.transform(a, false);
	transform.transform(b, false);
	for(int i = 0; i < pw; i++) a[i] = (U(a[i]) * b[i]).val;
	transform.transform(a, true);
	for(int i = 1; i <= n; i++){
		U ans = kit.coef(n, i) * n;
		ans -= kit.ifat[i] * a[half + i];
		cout << ans << endl;
	}
	return 0;
}


Measured memory_bytes: 58496