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

using ll = long long;

namespace mod
{
    static const auto P = 924844033;
    static const auto generator = 44009197;
    static const auto log_order = 21;
};

int power(const int a, const int k)
{
    if (k == 0) return 1;
    else
    {
        const auto square = int(ll(a) * a % mod::P);
        if (k % 2 == 0) return power(square, k/2);
        else return int(ll(a) * power(square, k/2) % mod::P);
    }
}
int inverse(const int a) { return power(a, mod::P-2); }

namespace bit
{
    bool test(const int mask, const int k) { return mask & 1<<k; }
    int set(const int mask, const int k) { return mask | 1<<k; }
}

struct NTT
{
    int N, N_inverse;
    vector<int> reverses;
    vector<int> roots;

    NTT(const int log) : N(1<<log), N_inverse(inverse(N)), reverses(N), roots(N/2)
    {
        for (auto i = 0; i < N; i++)
            for (auto k = 0; k < log; k++) if (bit::test(i, k))
                reverses[i] = bit::set(reverses[i], log-1-k);

        auto generator = mod::generator;
        for (auto i = 0; i < mod::log_order - log; i++)
            generator = int(ll(generator) * generator % mod::P);

        roots[0] = 1;
        for (auto i = 1; i < N/2; i++)
            roots[i] = int(ll(roots[i-1]) * generator % mod::P);
    }

    vector<int> transform(vector<int> a) const
    {
        for (auto i = 0; i < N; i++) if (i < reverses[i])
            swap(a[i], a[reverses[i]]);

        for (auto length = 2; length <= N; length *= 2)
        {
            for (auto i = 0; i < N; i += length)
            {
                auto l = begin(a)+i, r = l+length/2;
                for (auto root = begin(roots); root != end(roots); root += N / length, l++, r++)
                {
                    const auto u = *l, v = int(ll(*root) * *r % mod::P);
                    *l = u + v;
                    if (*l >= mod::P) *l -= mod::P;
                    *r = u - v;
                    if (*r < 0) *r += mod::P;
                }
            }
        }

        return a;
    }

    vector<int> inverse_transform(vector<int> a) const
    {
        a = transform(move(a));
        for (auto& x : a) x = int(ll(x) * N_inverse % mod::P);
        reverse(begin(a)+1, end(a));
        return a;
    }

    vector<int> convolve(vector<int> a, vector<int> b) const
    {
        const auto Fa = transform(move(a));
        const auto Fb = transform(move(b));

        auto Fc = vector<int>(N);
        for (auto i = 0; i < N; i++)
            Fc[i] = int(ll(Fa[i]) * Fb[i] % mod::P);

        return inverse_transform(move(Fc));
    }
};

struct Tree
{
    int N;
    vector<vector<int>> adjacency_list;

    Tree(const int N) : N(N), adjacency_list(N) {}

    void add_edge(const int a, const int b)
    {
        adjacency_list[a].push_back(b);
        adjacency_list[b].push_back(a);
    }

    vector<int> solve() const
    {
        auto subtree_sizes = vector<int>(N);
        const function<void(int, int)> dfs = [&](const int v, const int parent)
        {
            subtree_sizes[v] = 1;
            for (const auto w : adjacency_list[v]) if (w != parent)
            {
                dfs(w, v);
                subtree_sizes[v] += subtree_sizes[w];
            }
        };
        dfs(0, -1);

        auto coefficients = vector<int>(N+1);
        coefficients[N] = N;
        for (auto i = 1; i < N; i++)
        {
            const auto x = subtree_sizes[i];
            coefficients[x]--;
            if (coefficients[x] < 0) coefficients[x] += mod::P;
            coefficients[N-x]--;
            if (coefficients[N-x] < 0) coefficients[N-x] += mod::P;
        }

        auto factorials = vector<int>(N+1);
        factorials[0] = 1;
        for (auto i = 1; i <= N; i++)
            factorials[i] = int(ll(factorials[i-1]) * i % mod::P);

        auto inverse_factorials = vector<int>(N+1);
        inverse_factorials[N] = inverse(factorials[N]);
        for (auto i = N; i >= 1; i--)
            inverse_factorials[i-1] = int(ll(i) * inverse_factorials[i] % mod::P);

        auto log = 0; while (1<<log < 2*N+1) log++;

        auto c = vector<int>(1<<log);
        for (auto n = 0; n <= N; n++)
            c[n] = int(ll(coefficients[n]) * factorials[n] % mod::P);

        auto d = vector<int>(1<<log);
        for (auto n = -N; n <= 0; n++)
            d[N+n] = inverse_factorials[-n];

        const auto convolution = NTT(log).convolve(c, d);

        auto result = vector<int>(N);
        for (auto k = 1; k <= N; k++)
            result[k-1] = int(ll(inverse_factorials[k]) * convolution[N+k] % mod::P);

        return result;
    }
};

int main()
{
    ios::sync_with_stdio(false);

    int N; cin >> N;

    auto tree = Tree(N);

    for (auto i = 0; i < N-1; i++)
    {
        int a, b; cin >> a >> b;
        a--; b--;
        tree.add_edge(a, b);
    }

    for (const auto x : tree.solve())
        cout << x << "\n";
}


Measured memory_bytes: 43520