#include <cstdio>
#include <cstring>
#include <iostream>
#include <string>
#include <cmath>
#include <bitset>
#include <vector>
#include <map>
#include <set>
#include <queue>
#include <deque>
#include <algorithm>
#include <complex>
#include <unordered_map>
#include <unordered_set>
#include <random>
#include <cassert>
using namespace std;
typedef long long int ll;
typedef pair<int, int> Pii;

#define FOR(i,n) for(int i = 0; i < (n); i++)
#define sz(c) ((int)(c).size())
#define ten(x) ((int)1e##x)

template<class T> T extgcd(T a, T b, T& x, T& y) { for (T u = y = 1, v = x = 0; a;) { T q = b / a; swap(x -= q * u, u); swap(y -= q * v, v); swap(b -= q * a, a); } return b; }
template<class T> T mod_inv(T a, T m) { T x, y; extgcd(a, m, x, y); return (m + x % m) % m; }
ll mod_pow(ll a, ll n, ll mod) { ll ret = 1; ll p = a % mod; while (n) { if (n & 1) ret = ret * p % mod; p = p * p % mod; n >>= 1; } return ret; }

template<int mod, int primitive_root>
class NTT {
public:
	int get_mod() const { return mod; }
	void _ntt(vector<ll>& a, int sign) {
		const int n = sz(a);
		assert((n ^ (n&-n)) == 0); //n = 2^k

		const int g = 5; //g is primitive root of mod
		int h = (int)mod_pow(g, (mod - 1) / n, mod); // h^n = 1
		if (sign == -1) h = (int)mod_inv(h, mod); //h = h^-1 % mod

		//bit reverse
		int i = 0;
		for (int j = 1; j < n - 1; ++j) {
			for (int k = n >> 1; k >(i ^= k); k >>= 1);
			if (j < i) swap(a[i], a[j]);
		}

		for (int m = 1; m < n; m *= 2) {
			const int m2 = 2 * m;
			const ll base = mod_pow(h, n / m2, mod);
			ll w = 1;
			FOR(x, m) {
				for (int s = x; s < n; s += m2) {
					ll u = a[s];
					ll d = a[s + m] * w % mod;
					a[s] = u + d;
					if (a[s] >= mod) a[s] -= mod;
					a[s + m] = u - d;
					if (a[s + m] < 0) a[s + m] += mod;
				}
				w = w * base % mod;
			}
		}

		for (auto& x : a) if (x < 0) x += mod;
	}
	void ntt(vector<ll>& input) {
		_ntt(input, 1);
	}
	void intt(vector<ll>& input) {
		_ntt(input, -1);
		const int n_inv = mod_inv(sz(input), mod);
		for (auto& x : input) x = x * n_inv % mod;
	}

	// 畳み込み演算を行う
	vector<ll> convolution(const vector<ll>& a, const vector<ll>& b){
		int ntt_size = 1;
		while (ntt_size < sz(a) + sz(b)) ntt_size *= 2;

		vector<ll> _a = a, _b = b;
		_a.resize(ntt_size); _b.resize(ntt_size);

		ntt(_a);
		ntt(_b);

		FOR(i, ntt_size){
			(_a[i] *= _b[i]) %= mod;
		}

		intt(_a);
		return _a;
	}
};

const ll MOD=924844033;
typedef NTT<MOD, 5> NTT_1;

ll powmod(ll a, ll k){
    ll ap=a, ans=1;
    while(k){
        if(k&1){
            ans*=ap;
            ans%=MOD;
        }
        ap=ap*ap;
        ap%=MOD;
        k>>=1;
    }
    return ans;
}
ll inv(ll a){
	return powmod(a, MOD-2);
}
ll f[200001], invf[200001];
void fac(int n){
    f[0]=1;
    for(ll i=1; i<=n; i++) f[i]=f[i-1]*i%MOD;
    invf[n]=inv(f[n]);
    for(ll i=n-1; i>=0; i--) invf[i]=invf[i+1]*(i+1)%MOD;
}
ll comb(int x, int y){
    if(x<y) return 0;
    return f[x]*invf[y]%MOD*invf[x-y]%MOD;
}
int n;
vector<int> g[200001];
bool used[200001];
int ct[200001];
ll c[200001];
void dfs(int x){
  used[x]=1;
  ct[x]=1;
  for(auto y:g[x]){
    if(!used[y]){
      dfs(y);
      ct[x]+=ct[y];
      c[ct[y]]++;
    }
  }
  c[n-ct[x]]++;
}
vector<ll> add(vector<ll> a, vector<ll> b){
  int m=max(a.size(), b.size());
  vector<ll> ret(m, 0);
  for(int i=0; i<a.size(); i++){
    ret[i]=a[i];
  }
  for(int i=0; i<b.size(); i++){
    ret[i]+=b[i];
    if(ret[i]>=MOD) ret[i]-=MOD;
  }
  return ret;
}
vector<ll> solve(int l, int r){
  if(l==r){
    vector<ll> ret(1, c[l]);
    return ret;
  }
  int m=(l+r)/2;
  vector<ll> p=solve(l, m);
  vector<ll> q0(m+2-l);
  for(int i=0; i<=m+1-l; i++){
    q0[i]=comb(m+1-l, i);
  }
  vector<ll> q1=solve(m+1, r);
  NTT_1 ntt1;
  vector<ll> q=ntt1.convolution(q0, q1);
  vector<ll> ret=add(p, q);
  ret.resize(r-l+1);
  return ret;
}
int main()
{
	cin>>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);
  }
  dfs(0);
  fac(n);
  vector<ll> ans=solve(0, n-1);
  for(ll i=1; i<n; i++){
    cout<<(comb(n, i)*(ll)n-ans[i]+MOD)%MOD<<endl;
  }
  cout<<n<<endl;
	return 0;
}

Measured memory_bytes: 39020