#include<bits/stdc++.h>
using namespace std;

namespace NTT {
    int N;
    vector<int> perm;
    vector<int>wp[2][30];
    const int mod = 924844033, root = 44009197, inv = 921713838, pw = 1<<21;

    int power(int a, int p) {
        if (p==0)   return 1;
        int ans = power(a, p/2);
        ans = (ans * 1LL * ans)%mod;
        if (p%2)    ans = (ans * 1LL * a)%mod;
        return ans;
    }

    void precalculate() {
        perm.resize(N);
        perm[0] = 0;

        for (int k=1; k<N; k<<=1) {
            for (int i=0; i<k; i++) {
                perm[i] <<= 1;
                perm[i+k] = 1 + perm[i];
            }
        }

        for (int b=0; b<2; b++) {
            for (int idx = 0, len = 2; len <= N; idx++, len <<= 1) {
                int factor = b ? inv : root;
                for (int i = len; i < pw; i <<= 1)
                    factor = (factor*1LL*factor)%mod;

                wp[b][idx].resize(N);
                wp[b][idx][0] = 1;
                for (int i = 1; i < len; i++) {
                    wp[b][idx][i] = (wp[b][idx][i-1]*1LL*factor)%mod;
                }
            }
        }
    }

    void fft(vector<int> &v, bool invert = false) {
        if (v.size() != perm.size()) {
            N = v.size();
            assert(N && (N&(N-1)) == 0);
            precalculate();
        }

        for (int i=0; i<N; i++)
            if (i < perm[i])
                swap(v[i], v[perm[i]]);

        for (int idx = 0, len = 2; len <= N; idx++, len <<= 1) {
            for (int i=0; i<N; i+=len) {
                for (int j=0; j<len/2; j++) {
                    int x = v[i+j];
                    int y = (wp[invert][idx][j]*1LL*v[i+j+len/2])%mod;
                    v[i+j] = (x+y>=mod ? x+y-mod : x+y);
                    v[i+j+len/2] = (x-y>=0 ? x-y : x-y+mod);
                }
            }
        }
        if (invert) {
            int n1 = power(N, mod-2);
            for (int &x : v) x = (x*1LL*n1)%mod;
        }
    }

    vector<int> multiply(vector<int> a, vector<int> b) {
        int n = 1;
        while (n < a.size()+ b.size())  n<<=1;
        a.resize(n);
        b.resize(n);

        fft(a);
        fft(b);
        for (int i=0; i<n; i++) a[i] = (a[i] * 1LL * b[i])%mod;
        fft(a, true);
        return a;
    }
};

const int N = 2e5+7, M = 924844033;
int power(int a, int p) {
    if (p == 0) return 1;
    int ans = power(a, p/2);
    ans = (1LL*ans * ans)%M;
    if (p%2)    ans = (1LL*ans*a)%M;
    return ans;
}

int fac[N], invfac[N];
void pre() {
    fac[0] = 1;
    for(int i=1; i<N; i++)  fac[i] = (1LL*i*fac[i-1])%M;
    invfac[N-1] = power(fac[N-1], M-2);
    for (int i=N-2; i>=0; i--)  invfac[i] = (1LL*invfac[i+1]*(i+1))%M;
}

int C(int n, int r) {
    if (r<0 || r>n) return 0;
    int denom = (1LL*invfac[r]*invfac[n-r])%M;
    return (1LL*fac[n]*denom)%M;
}

vector<int> adj[N];

int sz[N];
int con[N];
int n;

void addEdge(int u, int v) {
    adj[u].push_back(v);
    adj[v].push_back(u);
}

void setup(int u, int par) {
    sz[u] = 1;
    for (int v: adj[u]) {
        if (v == par)   continue;
        setup(v, u);
        sz[u] += sz[v];
    }
    if (par) {
        con[n]++;
        con[sz[u]]--;
        con[n-sz[u]]--;
    }
}


int primitive_root(int p) {
    if (p == 2) return 1;
    vector<int> factor;
    int phi = p-1,  n = phi;

    for (int i=2; i*i<=n; ++i)
        if (n%i == 0) {
            factor.push_back (i);
            while (n%i==0)  n/=i;
        }

    if (n>1)  factor.push_back(n);

    for (int res=2; res<=p; ++res) {
        bool ok = true;
        for (int i=0; i<factor.size() && ok; ++i)
            ok &= power(res, phi/factor[i]) != 1;
        if (ok)  return res;
    }
    return -1;
}


/**
  Generates necessary info for NTT (for offline usage :3)
  returns maximum k such that 2^k divides mod
  ntt can only be applied for arrays not larger than this size
  mod MUST BE PRIME!!!!!
  We use that fact that primes the form p=c*2^k+1,
  there always exist the 2^k-th root of unity.
  It can be shown that g^c is such a 2^k-th root
  of unity, where g is a primitive root of p.
*/


int nttdata(int mod, int &root, int &inv, int &pw) {
    int c = 0, n = mod-1;
    while (n%2 == 0) c++, n/=2;
    pw = (mod-1)/n;
    int g = primitive_root(mod);
    root = power(g, n);
    inv = power(root, mod-2);
    return c;
}


int main() {
    ios::sync_with_stdio(0);
    cin.tie(0);

    cin>>n;
    pre();

    for (int i=1; i<n; i++) {
        int u, v;
        cin>>u>>v;
        addEdge(u, v);
    }
    setup(1, 0);

    vector<int> a(n+1), b(n+1);
    for (int i=0; i<=n; i++) {
        if(con[i] < 0)  con[i] += M;
        a[i] = (1LL*con[i]*fac[i])%M;
        b[i] = invfac[i];
    }
    reverse(b.begin(), b.end());

    vector<int> mul = NTT::multiply(a, b);
    for (int i=1; i<=n; i++) {
        int ans = mul[n+i];
        ans = (1LL*ans*invfac[i])%M;
        ans = (ans + C(n, i))%M;
        cout<<ans<<"\n";
    }

}


Measured memory_bytes: 116300