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

using ll = long long;

struct Mod
{
    static const auto P = 924844033;
    static const auto primitive_root = 116636802;
    static const auto log = 19;

    ll k;

    Mod() = default;
    Mod(ll 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 Complex { double real, imag; };
Complex conj(const Complex z) { return {z.real, -z.imag}; }
Complex operator+(const Complex z, const Complex w) { return {z.real+w.real, z.imag+w.imag}; }
Complex operator-(const Complex z, const Complex w) { return {z.real-w.real, z.imag-w.imag}; }
Complex operator*(const Complex z, const Complex w) { return {z.real*w.real - z.imag*w.imag, z.real*w.imag + z.imag*w.real}; }
Complex operator/(const Complex z, const int n) { return {z.real/n, z.imag/n}; }
Complex& operator/=(Complex& z, const int n) { return z = z/n; }

struct FFT
{
    int n;
    vector<int> reverses;
    vector<Complex> roots;

    FFT(const int log) : n(1<<log), 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);

        const auto pi = 4*atan(1);
        for (auto i = 0; i < n/2; i++)
            roots[i] = Complex{cos(2*pi*i/n), sin(2*pi*i/n)};
    }

    vector<Complex> transform(vector<Complex> 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)
        {
            auto generator = n / length;
            for (auto j = 0; j < n; j += length)
            {
                auto l = begin(a)+j, r = begin(a)+j+(length/2);
                auto root = begin(roots);
                for (auto k = 0; k < length/2; k++)
                {
                    auto u = *l, v = *r * *root;
                    *l = u + v;
                    *r = u - v;
                    l++, r++, root += generator;
                }
            }
        }

        return a;
    }

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

    vector<ll> mod_convolve(const vector<ll>& a, const vector<ll>& b) const
    {
        const auto pack = [](ll x)
        {
            auto real = static_cast<double>(x >> 15);
            auto imag = static_cast<double>(x & ((1<<15) - 1));
            return Complex{real, imag};
        };

        auto a_packed = vector<Complex>(n);
        for (auto i = 0; i < n; i++)
            a_packed[i] = pack(a[i]);
        auto Fa = transform(move(a_packed));

        auto b_packed = vector<Complex>(n);
        for (auto i = 0; i < n; i++)
            b_packed[i] = pack(b[i]);
        auto Fb = transform(move(b_packed));

        auto Fab1 = vector<Complex>(n), Fab2 = vector<Complex>(n);
        for (auto i = 0; i < n; i++)
        {
            const auto j = i == 0 ? 0 : n-i;
            const auto Fa1 = Complex{0.5, 0} * (Fa[i] + conj(Fa[j]));
            const auto Fa2 = Complex{0, -0.5} * (Fa[i] - conj(Fa[j]));
            const auto Fb1 = Complex{0.5, 0} * (Fb[i] + conj(Fb[j]));
            const auto Fb2 = Complex{0, -0.5} * (Fb[i] - conj(Fb[j]));

            Fab1[i] = Fa1*Fb1 + Complex{0, 1}*Fa1*Fb2;
            Fab2[i] = Fa2*Fb1 + Complex{0, 1}*Fa2*Fb2;
        }

        auto ab1 = inverse_transform(move(Fab1));
        auto ab2 = inverse_transform(move(Fab2));

        auto result = vector<ll>(n);
        for (auto i = 0; i < n; i++)
        {
            const auto a1b1 = llround(ab1[i].real) % Mod::P;
            const auto a1b2 = llround(ab1[i].imag) % Mod::P;
            const auto a2b1 = llround(ab2[i].real) % Mod::P;
            const auto a2b2 = llround(ab2[i].imag) % Mod::P;

            result[i] = ((a1b1<<30) + (a1b2<<15) + (a2b1<<15) + a2b2) % Mod::P;
        }
        return result;
    }
};

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 c = vector<ll>(1<<Mod::log);
        for (auto n = 0; n <= N; n++)
            c[n] = (coefficients[n] * factorials[n]).k;

        auto d = vector<ll>(1<<Mod::log);
        for (auto n = -N; n <= 0; n++)
            d[N+n] = (inverse_factorials[-n]).k;

        const auto convolution = FFT(Mod::log).mod_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 << "\n";
}


Measured memory_bytes: 83072