#include <iostream>
#include <algorithm>
#include <iomanip>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <numeric>
#include <bitset>

static const int MOD = 924844033;
using ll = int64_t;
using u32 = uint32_t;
using namespace std;

template<class T> constexpr T INF = ::numeric_limits<T>::max()/32*15+208;

template <class T>
T pow_ (T x, T n, T M){
    uint64_t u = 1, xx = x;
    while (n > 0){
        if (n&1) u = u * xx % M;
        xx = xx * xx % M;
        n >>= 1;
    }
    return static_cast<T>(u);
};

template <class T> class Factorial {
    T mod;
    vector<uint64_t> facts, factinv;

public:
    Factorial(int n, T mod) : facts(static_cast<u32>(n+1)), factinv(static_cast<u32>(n+1)), mod(mod) {
        facts[0] = 1;
        for (int i = 1; i < n+1; ++i) facts[i] = facts[i-1]*i % mod;
        factinv[n] = pow_(facts[n], static_cast<uint64_t>(mod - 2), static_cast<uint64_t>(mod));
        for (int i = n-1; i >= 0; --i) factinv[i] = factinv[i+1] * (i+1) % mod;
    }

    T fact(int k) const {
        if(k >= 0) return static_cast<T>(facts[k]);
        else return static_cast<T>(factinv[-k]);
    }

    T operator[](const int &k) const {
        if(k >= 0) return static_cast<T>(facts[k]);
        else return static_cast<T>(factinv[-k]);
    }

    T C(int p, int q) const {
        if(q < 0 || p < q) return 0;
        return static_cast<T>(facts[p]*  factinv[q] % mod * factinv[p-q] % mod);
    }

    T P(int p, int q) const {
        if(q < 0 || p < q) return 0;
        return static_cast<T>((facts[p] * factinv[p-q]) % mod);
    }

    T H(int p, int q) const {
        if(p < 0 || q < 0) return 0;
        return static_cast<T>(q == 0 ? 1 : C(p+q-1, q));
    }
};



struct poly {
    vector<ll> v;
    poly() = default;
    explicit poly(vector<ll> vv) : v(std::move(vv)) {};
    int size() {return (int)v.size(); }
    poly cut(int len){
        if(len < v.size()) v.resize(static_cast<unsigned long>(len));
        return *this;
    }
    inline ll& operator[] (int i) {return v[i]; }
};

poly operator+(poly &A, poly &B){
    poly C;
    C.v = vector<ll>(max(A.size(), B.size()));
    for (int i = 0; i < A.size(); ++i) C[i] = A[i];
    for (int i = 0; i < B.size(); ++i) (C[i] += B[i]) %= MOD;
    return C;
}

poly operator-(poly &A, poly &B){
    poly C;
    C.v = vector<ll>(max(A.size(), B.size()));
    for (int i = 0; i < A.size(); ++i) C[i] = A[i];
    for (int i = 0; i < B.size(); ++i) (C[i] += MOD-B[i]) %= MOD;
    return C;
}


template<typename T>
T extgcd(T a, T b, T &x ,T &y){
    for (T u = y = 1, v = x = 0; a; ) {
        ll q = b/a;
        swap(x -= q*u, u);
        swap(y -= q*v, v);
        swap(b -= q*a, a);
    }
    return b;
}

template<typename T>
T mod_inv(T x, T m){
    T s, t;
    extgcd(x, m, s, t);
    return (m+s)% m;
}

class NTT {
    int mod, primitive_root;
public:
    explicit NTT(int mod, int pr): mod(mod), primitive_root(pr) {};
    void _ntt(poly &a, int sign){
        const int n = static_cast<const int>(a.size());
        const int g = primitive_root;
        int h = pow_(g, (mod - 1)/n, mod);
        if (sign == -1) h = mod_inv(h, mod);
        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 = pow_(h, n/m2, mod);
            ll w = 1;
            for (int x = 0; x < m; ++x) {
                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.v) if(x < 0) x += mod;
    }

    void ntt(poly& input){
        _ntt(input, 1);
    }

    void inv_ntt(poly &input){
        _ntt(input, -1);
        const int n_inv = mod_inv(static_cast<int>(input.size()), mod);
        for (auto &&x : input.v) x = x * n_inv % mod;
    }

    poly convolution(poly a, poly b){
        u32 ntt_size = 1;
        while(ntt_size < a.size() + b.size()) ntt_size *= 2;
        a.v.resize(ntt_size), b.v.resize(ntt_size);
        ntt(a);
        ntt(b);
        for (int i = 0; i < ntt_size; ++i) (a[i] *= b[i]) %= mod;
        inv_ntt(a);
        return a;
    }
};

poly operator* (poly &A, poly &B){
    poly C;
    NTT ntt(MOD, 5);
    C = ntt.convolution(A, B);
    return C;
}


int main() {
    int n;
    cin >> n;
    vector<vector<int>> G(n);
    for (int i = 0; i < n-1; ++i) {
        int a, b;
        scanf("%d %d", &a, &b);
        G[a-1].emplace_back(b-1);
        G[b-1].emplace_back(a-1);
    }
    deque<int> Q;
    vector<int> num(n);
    {
        stack<int> s;
        int cnt = 0;
        vector<int> visited(n, 0);
        s.emplace(0);
        while(!s.empty()){
            int a = s.top(); s.pop();
            visited[a]++;
            num[a] = cnt++;
            Q.emplace_front(a);
            for (auto &&i : G[a]) {
                if(!visited[i]) s.emplace(i);
            }
        }
    }
    vector<int> v(n, 1);
    vector<ll> u(n+1);
    while(!Q.empty()){
        int i = Q.front(); Q.pop_front();
        for (auto &&j : G[i]) {
            if(num[i] < num[j]) v[i] += v[j];
        }
    }
    for (int i = 0; i < n; ++i) {
        for (auto &&j : G[i]) {
            if(i < j){
                int p = min(v[i], v[j]);
                u[p]++; u[n-p]++;
            }
        }
    }

    Factorial<ll> fact(n, MOD);
    for (int i = 0; i <= n; ++i) {
        u[i] = (fact[i] * u[i]) % MOD;
    }
    vector<ll> uu(n+1);
    for (int i = 0; i <= n; ++i) {
        uu[i] = fact[i-n];
    }
    poly f(u), g(uu);
    poly h = f*g;
    for (int k = 1; k <= n; ++k) {
        ll ans = (fact.C(n, k)*n%MOD + (MOD - fact[-k]*h[n+k]%MOD)) % MOD;
        cout << ans << "\n";
    }
    return 0;
}


Measured memory_bytes: 33488