#include <bits/stdc++.h>
#define ll long long
using ull = unsigned long long;
using namespace std;
#define dump(x)                             \
    if (dbg) {                              \
        cerr << #x << " = " << (x) << endl; \
    }
#define overload4(_1, _2, _3, _4, name, ...) name
#define FOR1(n) for (ll i = 0; i < (n); ++i)
#define FOR2(i, n) for (ll i = 0; i < (n); ++i)
#define FOR3(i, a, b) for (ll i = (a); i < (b); ++i)
#define FOR4(i, a, b, c) for (ll i = (a); i < (b); i += (c))
#define FOR(...) overload4(__VA_ARGS__, FOR4, FOR3, FOR2, FOR1)(__VA_ARGS__)
#define FORR(i, a, b) for (int i = (a); i <= (b); ++i)
#define bit(n, k) ((n >> k) & 1) /*nのk bit目*/
namespace mydef {
const int INF = 1ll << 60;
const int MOD = 924844033;
template <class T>
bool chmin(T& a, const T& b) {
    if (a > b) {
        a = b;
        return 1;
    } else
        return 0;
}
template <class T>
bool chmax(T& a, const T& b) {
    if (a < b) {
        a = b;
        return 1;
    } else
        return 0;
}
void Yes(bool flag = true) {
    if (flag)
        cout << "Yes" << endl;
    else
        cout << "No" << endl;
}
void No(bool flag = true) {
    Yes(!flag);
}
void YES(bool flag = true) {
    if (flag)
        cout << "YES" << endl;
    else
        cout << "NO" << endl;
}
void NO(bool flag = true) {
    YES(!flag);
}
template <typename A, size_t N, typename T>
void Fill(A (&array)[N], const T& val) {
    std::fill((T*)array, (T*)(array + N), val);
}
bool dbg = true;
}  // namespace mydef
using namespace mydef;
#define pb push_back
#define mp make_pair
#define eb emplace_back
#define lb lower_bound
#define ub upper_bound
#define all(v) (v).begin(), (v).end()
#define SZ(x) ((int)(x).size())
#define vi vector<int>
#define vvi vector<vector<int>>
#define vp vector<pair<int, int>>
#define vvp vector<vector<pair<int, int>>>
#define pi pair<int, int>
//#define P pair<int, int>
//#define V vector<int>
//#define S set<int>
#define asn ans


static struct IO {
    char tmp[1 << 10];

    // fast input routines
    char cur;

    //#define nextChar() (cur = getc_unlocked(stdin))
    //#define peekChar() (cur)
    inline char nextChar() { return cur = getc_unlocked(stdin); }
    inline char peekChar() { return cur; }

    inline operator bool() { return peekChar(); }
    inline static bool isBlank(char c) { return (c < '-' && c); }
    inline bool skipBlanks() {
        while (isBlank(nextChar()))
            ;
        return peekChar() != 0;
    }

    inline IO& operator>>(char& c) {
        c = nextChar();
        return *this;
    }

    inline IO& operator>>(char* buf) {
        if (skipBlanks()) {
            if (peekChar()) {
                *(buf++) = peekChar();
                while (!isBlank(nextChar()))
                    *(buf++) = peekChar();
            }
            *(buf++) = 0;
        }
        return *this;
    }

    inline IO& operator>>(string& s) {
        if (skipBlanks()) {
            s.clear();
            s += peekChar();
            while (!isBlank(nextChar()))
                s += peekChar();
        }
        return *this;
    }

    inline IO& operator>>(double& d) {
        if ((*this) >> tmp)
            sscanf(tmp, "%lf", &d);
        return *this;
    }

#define defineInFor(intType)                         \
    inline IO& operator>>(intType& n) {              \
        if (skipBlanks()) {                          \
            int sign = +1;                           \
            if (peekChar() == '-') {                 \
                sign = -1;                           \
                n = nextChar() - '0';                \
            } else                                   \
                n = peekChar() - '0';                \
            while (!isBlank(nextChar())) {           \
                n += n + (n << 3) + peekChar() - 48; \
            }                                        \
            n *= sign;                               \
        }                                            \
        return *this;                                \
    }

    defineInFor(int)
        defineInFor(unsigned int)
            defineInFor(long long)

        // fast output routines

        //#define putChar(c) putc_unlocked((c), stdout)
        inline void putChar(char c) { putc_unlocked(c, stdout); }
    inline IO& operator<<(char c) {
        putChar(c);
        return *this;
    }
    inline IO& operator<<(const char* s) {
        while (*s)
            putChar(*s++);
        return *this;
    }

    inline IO& operator<<(const string& s) {
        for (int i = 0; i < (int)s.size(); ++i)
            putChar(s[i]);
        return *this;
    }

    char* toString(double d) {
        sprintf(tmp, "%lf%c", d, '\0');
        return tmp;
    }
    inline IO& operator<<(double d) { return (*this) << toString(d); }


#define defineOutFor(intType)                   \
    inline char* toString(intType n) {          \
        char* p = (tmp + 30);                   \
        if (n) {                                \
            bool isNeg = 0;                     \
            if (n < 0)                          \
                isNeg = 1, n = -n;              \
            while (n)                           \
                *--p = (n % 10) + '0', n /= 10; \
            if (isNeg)                          \
                *--p = '-';                     \
        } else                                  \
            *--p = '0';                         \
        return p;                               \
    }                                           \
    inline IO& operator<<(intType n) { return (*this) << toString(n); }

    defineOutFor(int)
        defineOutFor(long long)

#define endl ('\n')
#define cout __io__
#define cin __io__
} __io__;


template <signed mod>
struct NumberTheoreticTransform {
private:
    vector<signed> rev, rts;  //swap計算用の配列, \omega^iに相当するもの
    signed base, max_base, root;
    inline signed mod_add(signed a, signed b) {
        a += b;
        if (a >= mod)
            a -= mod;
        return a;
    }
    inline signed mod_mul(signed a, signed b) {
        return (1ull * a * b) % (unsigned long long)mod;
    }
    inline signed mod_pow(signed a, signed n) {
        signed ret = 1;
        while (n) {
            if (n & 1)
                ret = mod_mul(ret, a);
            a = mod_mul(a, a);
            n >>= 1;
        }
        return ret;
    }
    inline signed mod_inv(signed a) {
        return mod_pow(a, mod - 2);
    }
    //
public:
    NumberTheoreticTransform() : base(1), rev{0, 1}, rts{0, 1} {
        assert(mod >= 3 && mod & 1 == 1);
        signed tmp = mod - 1;
        max_base = 0;
        while (tmp % 2 == 0) {
            tmp >>= 1;
            max_base++;
        }
        root = 2;
        while (mod_pow(root, (mod - 1) >> 1) == 1)
            root++;
        assert(mod_pow(root, mod - 1) == 1);
        root = mod_pow(root, (mod - 1) >> max_base);
    }
    //
private:
    void ensure_base(signed nbase) {
        if (nbase <= base)
            return;
        assert(nbase <= max_base);
        rev.resize(1 << nbase);
        rts.resize(1 << nbase);
        for (signed i = 0; i < (1 << nbase); i++) {
            rev[i] = (rev[i >> 1] >> 1) + ((i & 1) << (nbase - 1));
        }
        while (base < nbase) {
            signed z = mod_pow(root, 1 << (max_base - 1 - base));
            for (signed i = 1 << (base - 1); i < (1 << base); i++) {
                rts[i << 1] = rts[i];
                rts[(i << 1) + 1] = mod_mul(rts[i], z);
            }
            base++;
        }
    }
    void ntt(vector<signed>& a) {
        const signed n = (signed)a.size();
        assert((n & (n - 1)) == 0);
        signed zeros = __builtin_ctz(n);
        ensure_base(zeros);
        signed shift = base - zeros;
        for (signed i = 0; i < n; i++) {
            if (i < (rev[i] >> shift))
                swap(a[i], a[rev[i] >> shift]);
        }
        for (signed k = 1; k < n; k <<= 1) {
            for (signed i = 0; i < n; i += 2 * k) {
                for (signed j = 0; j < k; j++) {
                    signed z = mod_mul(a[i + j + k], rts[j + k]);
                    a[i + j + k] = mod_add(a[i + j], mod - z);
                    a[i + j] = mod_add(a[i + j], z);
                }
            }
        }
    }
    //
public:
    vector<signed> multiply(vector<signed> a, vector<signed> b) {
        if (a.empty() || b.empty())
            return {};
        bool eq = (a == b);
        signed need = a.size() + b.size() - 1;
        signed nbase = 1;
        while ((1 << nbase) < need)
            nbase++;
        ensure_base(nbase);
        signed sz = 1 << nbase;
        a.resize(sz, 0);
        b.resize(sz, 0);
        ntt(a);
        if (eq)
            b = a;
        else
            ntt(b);
        signed inv_sz = mod_inv(sz);
        for (signed i = 0; i < sz; i++) {
            a[i] = mod_mul(a[i], mod_mul(b[i], inv_sz));
        }
        reverse(a.begin() + 1, a.end());
        ntt(a);
        a.resize(need);
        return a;
    }
    vector<long long> multiply(vector<long long> a, vector<long long> b) {
        vector<signed> A(a.size()), B(b.size());
        for (signed i = 0; i < a.size(); i++) {
            A[i] = a[i];
        }
        for (signed i = 0; i < b.size(); i++) {
            B[i] = b[i];
        }
        A = multiply(A, B);
        a.resize(A.size());
        for (signed i = 0; i < A.size(); i++)
            a[i] = A[i];
        return a;
    }
};

template <typename sum_t, typename key_t>
struct ReRooting {
    struct Edge {
        int to;
        key_t data;
        sum_t dp, ndp;
    };

    using F = function<sum_t(sum_t, sum_t)>;
    using G = function<sum_t(sum_t, key_t)>;

    vector<vector<Edge>> g;
    vector<sum_t> subdp, dp;
    const sum_t ident;
    const F f;
    const G gg;

    ReRooting(int V, const F f, const G g, const sum_t& ident)
        : g(V), f(f), gg(g), ident(ident), subdp(V, ident), dp(V, ident) {}

    void add_edge(int u, int v, const key_t& d) {
        g[u].emplace_back((Edge){v, d, ident, ident});
        g[v].emplace_back((Edge){u, d, ident, ident});
    }

    void add_edge_bi(int u, int v, const key_t& d, const key_t& e) {
        g[u].emplace_back((Edge){v, d, ident, ident});
        g[v].emplace_back((Edge){u, e, ident, ident});
    }

    void dfs_sub(int idx, int par) {
        for (auto& e : g[idx]) {
            if (e.to == par)
                continue;
            dfs_sub(e.to, idx);
            subdp[idx] = f(subdp[idx], gg(subdp[e.to], e.data));
        }
    }

    void dfs_all(int idx, int par, const sum_t& top) {
        sum_t buff{ident};
        for (int i = 0; i < (int)g[idx].size(); i++) {
            auto& e = g[idx][i];
            e.ndp = buff;
            e.dp = gg(par == e.to ? top : subdp[e.to], e.data);
            buff = f(buff, e.dp);
        }
        dp[idx] = buff;
        buff = ident;
        for (int i = (int)g[idx].size() - 1; i >= 0; i--) {
            auto& e = g[idx][i];
            if (e.to != par)
                dfs_all(e.to, idx, f(e.ndp, buff));
            e.ndp = f(e.ndp, buff);
            buff = f(buff, e.dp);
        }
    }

    vector<sum_t> build() {
        dfs_sub(0, -1);
        dfs_all(0, -1, ident);
        return dp;
    }
};

int N, a[202020], b[202020];

template <uint MD>
struct ModInt {
    using M = ModInt;
    const static M G;
    uint v;
    ModInt(ll _v = 0) { set_v(_v % MD + MD); }
    M& set_v(uint _v) {
        v = (_v < MD) ? _v : _v - MD;
        return *this;
    }
    explicit operator bool() const { return v != 0; }
    M operator-() const { return M() - *this; }
    M operator+(const M& r) const { return M().set_v(v + r.v); }
    M operator-(const M& r) const { return M().set_v(v + MD - r.v); }
    M operator*(const M& r) const { return M().set_v(ull(v) * r.v % MD); }
    M operator/(const M& r) const { return *this * r.inv(); }
    M& operator+=(const M& r) { return *this = *this + r; }
    M& operator-=(const M& r) { return *this = *this - r; }
    M& operator*=(const M& r) { return *this = *this * r; }
    M& operator/=(const M& r) { return *this = *this / r; }
    bool operator==(const M& r) const { return v == r.v; }
    M pow(ll n) const {
        M x = *this, r = 1;
        while (n) {
            if (n & 1)
                r *= x;
            x *= x;
            n >>= 1;
        }
        return r;
    }
    M inv() const { return pow(MD - 2); }
    /*
    M inv() const {
        long long b = MD, u = 1, v = 0;
        long long a = (*this).v;
        while (b) {
            long long t = a / b;
            a -= t * b;
            swap(a, b);
            u -= t * v;
            swap(u, v);
        }
        u %= MD;
        if (u < 0)
            u += MD;
        return M{u};
    }
    */
    friend ostream& operator<<(ostream& os, const M& r) { return os << r.v; }
    friend istream& operator>>(istream& is, M& r) { return is >> r.v; }
};

using Mint = ModInt<MOD>;
const int MN = 2000010;
Mint fact[MN], iFac[MN];

void first() {
    fact[0] = Mint(1);
    for (int i = 1; i < MN; i++)
        fact[i] = fact[i - 1] * Mint(i);
    iFac[MN - 1] = fact[MN - 1].inv();
    for (int i = MN - 1; i >= 1; i--) {
        iFac[i - 1] = iFac[i] * Mint(i);
    }
    assert(fact[2345] * iFac[2345] == Mint(1));
}
Mint C(int n, int k) {
    if (n < k || k < 0)
        return Mint(0);
    return fact[n] * iFac[k] * iFac[n - k];
}

void solve() {
    int memo[202020] = {};
    vector<Mint> cnt(N, Mint{0});
    ReRooting<int, int> g(
        N,
        [](int a, int b) { return a + b; },
        [&](int x, int i) {
            memo[i] = x + 1;
            return x + 1;
        },
        0);
    for (int i = 0; i < N - 1; i++) {
        g.add_edge(a[i], b[i], i);
    }
    g.build();

    for (int i = 0; i < N - 1; i++) {
        if (memo[i] == 0)
            continue;
        cnt[memo[i]] += 1;
        cnt[N - memo[i]] += 1;
    }

    first();
    vector<int> A(N, 0), B(N + 1, 0);
    for (int i = 0; i < N; i++) {
        A[i] = (fact[i] * cnt[i]).v;
    }
    for (int i = 0; i <= N; i++) {
        B[i] = iFac[N - i].v;
    }

    NumberTheoreticTransform<MOD> ntt;
    auto ans = ntt.multiply(A, B);


    for (int K = 1; K <= N; K++) {
        cout << (int)(C(N, K) * N - iFac[K] * ans[N + K]).v << endl;
    }
}


signed main() {

    cin >> N;
    for (int i = 0; i < N - 1; i++) {
        cin >> a[i] >> b[i];
        a[i]--;
        b[i]--;
    }


    solve();
    return 0;
}


Measured memory_bytes: 73084