#include <bits/stdc++.h>
#define SZ(x) ((int) (x).size())
using namespace std;

typedef long long i64;

#define double long double
namespace FastFourierTransform {
    const double PI = acos(-1);

    struct Complex {
        double real, imag;
        Complex(const double _real = 0, const double _imag = 0):
            real(_real), imag(_imag) {}
        Complex operator*(const Complex& other) const {
            return Complex(real * other.real - imag * other.imag,
                           real * other.imag + imag * other.real);
        }
        void operator*=(const Complex& other) {
            double aux = real * other.real - imag * other.imag;
            imag = real * other.imag + imag * other.real;
            real = aux;
        }
        Complex operator+(const Complex& other) const {
            return Complex(real + other.real, imag + other.imag);
        }
        void operator+=(const Complex& other) {
            real += other.real;
            imag += other.imag;
        }
        Complex operator-(const Complex& other) const {
            return Complex(real - other.real, imag - other.imag);
        }
        void operator-=(const Complex& other) {
            real -= other.real;
            imag -= other.imag;
        }
        void operator/=(const double other) {
            real /= other;
            imag /= other;
        }
    };

    void fft(vector<Complex>& a, bool invert) {
        int n = a.size();
        for (int i = 1, j = 0; i < n; ++i) {
            int bit = n >> 1;
            for (; j >= bit; bit >>= 1) {
                j -= bit;
            }
            j += bit;
            if (i < j) {
                swap(a[i], a[j]);
            }
        }
        for (int len = 2; len <= n; len <<= 1) {
            int halfLen = len >> 1;
            double angle = 2 * PI / len * (invert ? -1: 1);
            Complex wl(cos(angle), sin(angle));
            for (int i = 0; i < n; i += len) {
                Complex w(1);
                for (int j = 0; j < halfLen; ++j) {
                    Complex u = a[i + j], v = w * a[i + j + halfLen];
                    a[i + j] = u + v;
                    a[i + j + halfLen] = u - v;
                    w *= wl;
                }
            }
        }
        if (invert) {
            for (int i = 0; i < n; ++i) {
                a[i] /= n;
            }
        }
    }

    vector<int64_t> multiply(const vector<int64_t>& a, const vector<int64_t>& b) {
        int n1 = a.size(), n2 = b.size();
        int m = 1;
        while (m < n1 || m < n2) m <<= 1;
        m <<= 1;

        vector<Complex> fa(m, 0), fb(m, 0);
        for (int i = 0; i < n1; ++i) {
            fa[i] = a[i];
        }
        for (int i = 0; i < n2; ++i) {
            fb[i] = b[i];
        }
        fft(fa, false);
        fft(fb, false);
        for (int i = 0; i < m; ++i) {
            fa[i] *= fb[i];
        }
        fft(fa, true);
        vector<int64_t> res(m);
        for (int i = 0; i < m; ++i) {
            res[i] = (int64_t) (fa[i].real + 0.5);
        }
        return res;
    }

    vector<int64_t> modMultiply(const vector<int64_t>& a,
                                const vector<int64_t>& b,
                                const int MOD) {
        int n = SZ(a);
        int SQ = sqrt(MOD);
        vector<int64_t> s1(n), s2(n), s3(n), s4(n);
        for (int i = 0; i < n; ++i) {
            s1[i] = a[i] % SQ;
            s2[i] = a[i] / SQ;
            s3[i] = b[i] % SQ;
            s4[i] = b[i] / SQ;
        }
        vector<int64_t> r1 = multiply(s1, s3);
        vector<int64_t> r2 = multiply(s1, s4);
        vector<int64_t> r3 = multiply(s2, s3);
        vector<int64_t> r4 = multiply(s2, s4);
        r1.resize(n);
        for (int i = 0; i < n; ++i) {
            r1[i] += (r2[i] + r3[i]) % MOD * SQ % MOD;
            r1[i] += r4[i] % MOD * SQ % MOD * SQ % MOD;
            r1[i] %= MOD;
        }
        return r1;

    }
}
#undef double


const int NMAX = 200005;
const int MOD = 924844033;

vector<int> G[NMAX];
int treeSize[NMAX];

void dfs(int node, int prev) {
    treeSize[node] = 1;
    for (int to: G[node]) {
        if (to != prev) {
            dfs(to, node);
            treeSize[node] += treeSize[to];
        }
    }
}

int Pow(int x, int y) {
    int ret = 1;
    for (; y > 0; y /= 2) {
        if (y & 1) {
            ret = (int64_t) ret * x % MOD;
        }
        x = (int64_t) x * x % MOD;
    }
    return ret;
}

int main() {
    #ifdef LOCAL_RUN
    freopen("task.in", "r", stdin);
    freopen("task.out", "w", stdout);
    //freopen("task.err", "w", stderr);
    #endif // ONLINE_JUDGE
    ios::sync_with_stdio(false);
    cin.tie(0);

    int n;
    cin >> n;

    for (int i = 1; i < n; ++i) {
        int x, y;
        cin >> x >> y;
        G[x].push_back(y);
        G[y].push_back(x);
    }
    dfs(1, -1);

    vector<int64_t> fact(n + 1, 0);
    fact[0] = 1;
    for (int i = 1; i <= n; ++i) {
        fact[i] = fact[i - 1] * i % MOD;
    }
    vector<int64_t> invFact(n + 1, 0);
    invFact[n] = Pow(fact[n], MOD - 2);
    for (int i = n - 1; i >= 0; --i) {
        invFact[i] = invFact[i + 1] * (i + 1) % MOD;
    }

    vector<int64_t> xfact(2 * n + 1, 0);
    for (int i = 2; i <= n; ++i) {
        xfact[treeSize[i]]++;
        xfact[n - treeSize[i]]++;
    }
    for (int i = 0; i <= n; ++i) {
        xfact[i] = xfact[i] * fact[i] % MOD;
    }
    vector<int64_t> invf(2 * n + 1, 0);
    for (int i = 0; i <= n; ++i) {
        invf[i] = invFact[n - i];
    }

    vector<int64_t> res = FastFourierTransform::modMultiply(xfact, invf, MOD);
    for (int i = 1; i <= n; ++i) {
        int total = (int64_t) n * fact[n] % MOD * invFact[i] % MOD
            * invFact[n - i] % MOD;
        int sub = invFact[i] * (res[n + i] % MOD) % MOD;
        int ans = (total - sub + MOD) % MOD;
        cout << ans << '\n';
    }
}

Measured memory_bytes: 142824