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

struct Mod
{
    static const auto P = 924844033;
    static Mod generator() { return 44009197; }
    static const auto log_order = 21;

    long long k;

    Mod() = default;
    Mod(long long k) : k((k %= P) < 0 ? k+P : k) {}
};

Mod operator+(const Mod a, const Mod b) { return a.k + b.k; }
Mod operator-(const Mod a, const Mod b) { return a.k - b.k + Mod::P; }
Mod operator*(const Mod a, const Mod b) { return a.k * b.k; }
Mod power(const Mod a, const int k)
{
    if (k == 0) return 1;
    else if (k % 2 == 0) return power(a*a, k/2);
    else return a * power(a*a, k/2);
}
Mod inverse(const Mod a) { return power(a, Mod::P-2); }
Mod& operator*=(Mod& a, const Mod b) { return a = a*b; }

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;
    Mod N_inverse;
    vector<int> reverses;
    vector<Mod> 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 = generator * generator;

        roots[0] = 1;
        for (auto i = 1; i < N/2; i++)
            roots[i] = roots[i-1] * generator;
    }

    vector<Mod> transform(vector<Mod> 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 = *root * *r;
                    *l = u + v;
                    *r = u - v;
                }
            }
        }

        return a;
    }

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

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

        auto Fc = vector<Mod>(N);
        for (auto i = 0; i < N; i++)
            Fc[i] = Fa[i] * Fb[i];

        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<Mod> 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]--;
            coefficients[N-x]--;
        }

        auto factorials = vector<Mod>(N+1);
        factorials[0] = 1;
        for (auto i = 1; i <= N; i++)
            factorials[i] = factorials[i-1] * i;

        auto inverse_factorials = vector<Mod>(N+1);
        inverse_factorials[N] = inverse(factorials[N]);
        for (auto i = N; i >= 1; i--)
            inverse_factorials[i-1] = i * inverse_factorials[i];

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

        auto c = vector<Mod>(1<<log);
        for (auto n = 0; n <= N; n++)
            c[n] = coefficients[n] * factorials[n];

        auto d = vector<Mod>(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<Mod>(N);
        for (auto k = 1; k <= N; k++)
            result[k-1] = inverse_factorials[k] * convolution[N+k];

        return result;
    }
};

int main()
{
    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.k << endl;
}


Measured memory_bytes: 56320