#include <iostream>
#include <iosfwd>
#include <iomanip>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <ctime>
#include <cmath>
#include <cassert>
#include <cctype>
#include <climits>
#include <vector>
#include <bitset>
#include <set>
#include <queue>
#include <stack>
#include <map>
#include <deque>
#include <string>
#include <list>
#include <iterator>
#include <sstream>
#include <complex>
#include <fstream>
#include <functional>
#include <numeric>
#include <utility>
#include <algorithm>

using namespace std;

// MACROS_BEGIN
#define CLEAR() cerr << endl;
#define LET(x, a) __typeof(a) x = a
#define FOREACH(it, v) for (LET(it, (v).begin()); it != (v).end(); ++it)
#define REPEAT(i, n) for (int i = 0; i < (n); ++i)
// MACROS_END

// GENERIC_UTILITIES_BEGIN
template <class T> inline int size(const T& c) {return (int) c.size();}
inline long long two(int x) {return (1LL << (x));}

vector<string> split(string s, string delim) {
    s += delim[0];
    string tmp;
    vector<string> result;
    for (int i = 0; i < size(s); ++i) {
        if (delim.find(s[i]) == string::npos) {
            tmp.push_back(s[i]);
        }
        else {
            if (tmp != "") result.push_back(tmp);
            tmp.clear();
        }
    }
    return result;
}

template <class A, class B> void setMin(A& a, const B& b) {
    a = min(a, b);
}

template <class A, class B> void setMax(A& a, const B& b) {
    a = max(a, b);
}
// GENERIC_UTILITIES_END

// FAST_IO_BEGIN
// FAST_IO_END

// STANDARD_IO_BEGIN
#ifndef USING_FAST_IO
int readInt() {int N = -1; scanf("%d", &N); return N;}
double readDouble() {double D; scanf("%lf", &D); return D;}
string readString() {char buffer[1 << 20]; scanf("%s", buffer); return buffer;}
long long readLongLong() {long long N = -1; scanf("%lld", &N); return N;}
#endif // NOT DEFINED USING_FAST_IO
// STANDARD_IO_END


// OUTPUT_UTILITIES_BEGIN
template <class A, class B> ostream& operator << (ostream& o, const pair<A, B>& p);
template <class T> ostream& operator << (ostream& o, const vector<T>& v);
template <class A, class B> ostream& operator << (ostream& o, const map<A, B>& m);
template <class T> ostream& operator << (ostream& o, const set<T>& s);
template <class T> ostream& operator << (ostream& o, const queue<T>& q);
template <class T> ostream& operator << (ostream& o, const stack<T>& s);

template <class A, class B> ostream& operator << (ostream& o, const pair<A, B>& p) {
    o << "(" << p.first << "," << p.second << ")"; return o;
}

template <class T> ostream& operator << (ostream& o, const vector<T>& v) {
    o << "{"; bool first = true; FOREACH(it, v) { if (!first) o << ","; first = false; o << *it; } return o << "}";
}

template <class A, class B> ostream& operator << (ostream& o, const map<A, B>& m) {
    o << "{"; bool first = true; FOREACH(it, m) { if (!first) o << ","; first = false; o << *it; } return o << "}";
}

template <class T> ostream& operator << (ostream& o, const set<T>& s) {
    o << "{"; bool first = true; FOREACH(it, s) { if (!first) o << ","; first = false; o << *it; } return o << "}";
}

template <class T> ostream& operator << (ostream& o, const queue<T>& q) {
    o << "{"; bool first = true; queue<T> p = q; while (!p.empty()) { if (!first) o << ","; first = false; o << p.front(); p.pop(); } return o << "}";
}

template <class T> ostream& operator << (ostream& o, const stack<T>& s) {
    o << "{"; bool first = true; stack<T> r = s; while (!r.empty()) { if (!first) o << ","; first = false; o << r.top(); r.pop(); } return o << "}";
}
// OUTPUT_UTILITIES_END

// DEBUGGING_UTILITIES_BEGIN
// DEBUGGING SWITCH
#define PHOENIX_DEBUG

#ifdef PHOENIX_DEBUG
#define BUG(x) cerr << __LINE__ << ": " << #x << " = " << x << endl;
#else
#define BUG(...)
#endif
// DEBUGGING_UTILITIES_END

const double epsilon = 1e-8;
const int infinite    = 1000000000;
const long long infiniteLL = 1000000000000000000LL;
const long long modulo = 1000000007;
const long long MODULO = 924844033;

struct FastFourierTransformModulo {
    int MODULO;
    vector<int> roots;

    vector< vector<int> > cache;

    FastFourierTransformModulo(int _MODULO) {
        MODULO = _MODULO;

        for (int i = 2; i * i <= MODULO; ++i) {
            if (MODULO % i == 0) {
                cerr << "Non-prime Modulo " << MODULO << " with factor " << i << endl;
            }
        }

        int t = MODULO - 1;
        int p2 = 0;

        while (t % 2 == 0) {
            t /= 2;
            ++p2;
        }

        if (p2 == 0) {
            cerr << "Invalid state" << endl;
        }

        roots.resize(p2 + 1);
        int start = 0;

        for (start = 2; ; ++start) {
            if (power(start, (MODULO - 1) / 2) != 1) {
                break;
            }
        }

        int pw = MODULO - 1;

        for (int i = 0; i < p2; ++i) {
            roots[i] = power(start, pw);
            pw /= 2;
        }
    }

    int nextPowerOfTwo(int x) {
        if (x == 0) {
            return 1;
        }

        int y = 1;

        while (y < x) {
            y *= 2;
        }

        return y;
    }

    int calcInvBits(int at, int total) {
        int res = 0;
        int rev = total >> 1;

        for (int p2 = 1; p2 < total; p2 <<= 1, rev >>= 1) {
            if ((at & p2) != 0) {
                res |= rev;
            }
        }

        return res;
    }

    vector<int> getInvBits(int _size) {
        int logsize = log2(_size);

        if (logsize >= size(cache)) {
            while (size(cache) != logsize + 1) {
                cache.push_back(vector<int>());
            }
        }

        if (cache[logsize].empty()) {
            cache[logsize].resize(_size);

            for (int i = 0; i < _size; ++i) {
                cache[logsize][i] = calcInvBits(i, _size);
            }
        }

        return cache[logsize];
    }

    void fft(vector<int>& arr, bool inv) {
        if (nextPowerOfTwo(size(arr)) != size(arr)) {
            cerr << "Invalid size of array (not a power of two) = " << size(arr) << endl;
        }

        int N = size(arr);
        vector<int> invbits = getInvBits(N);

        for (int i = 0; i < N; ++i) {
            int j = invbits[i];

            if (j > i) {
                swap(arr[i], arr[j]);
            }
        }

        for (int p2 = 1, pow2 = 1; p2 < N; p2 *= 2, pow2 += 1) {
            int w = roots[pow2];

            if (inv) {
                w = power(w, MODULO - 2);
            }

            for (int big = 0; big < N; big += 2 * p2) {
                int cur = 1;

                for (int small = big; small < big + p2; ++small) {
                    int i = small;
                    int j = small + p2;
                    int u = arr[i];
                    int o = arr[j];
                    int v = (int) (o * (long long) cur % MODULO);
                    arr[i] = u + v;

                    if (arr[i] >= MODULO) {
                        arr[i] -= MODULO;
                    }

                    arr[j] = u - v;

                    if (arr[j] < 0) {
                        arr[j] += MODULO;
                    }

                    cur = (int) (cur * (long long) w % MODULO);
                }
            }
        }
    }

    int power(int a, int k) {
        if (k == 0) {
            return 1;
        }

        if (k % 2 == 0) {
            return power((int) (a * (long long) a % MODULO), k / 2);
        }

        return (int) ((a * (long long) power(a, k - 1)) % MODULO);
    }

    vector<int> pointwiseMultiply(vector<int>& a, vector<int>& b) {
        if (size(a) != size(b)) {
            cerr << "Invalid sizes " << size(a) << " " << size(b) << endl;
        }

        vector<int> c(size(a), 0);

        for (int i = 0; i < size(c); ++i) {
            c[i] = (int) (a[i] * (long long) b[i] % MODULO);
        }

        return c;
    }

    void appendZeros(vector<int>& x, int len) {
        while (size(x) < len) {
            x.push_back(0);
        }
    }

    vector<int> mul(vector<int>& a, vector<int>& b) {
        int len = nextPowerOfTwo(size(a) + size(b) - 1);
        appendZeros(a, len);
        appendZeros(b, len);
        fft(a, false);
        fft(b, false);

        vector<int> c = pointwiseMultiply(a, b);

        fft(c, true);
        int mult = power(size(c), MODULO - 2);

        for (int i = 0; i < size(c); ++i) {
            c[i] = (int) (c[i] * (long long) mult % MODULO);
        }

        return c;
    }
};

struct Solver {
    int N;
    vector< vector<int> > adj;

    vector<int> parent;
    vector<int> subtreeSize;

    void initialize(int _N) {
        N = _N;
        adj.resize(N);
    }

    void addEdge(int u, int v) {
        adj[u].push_back(v);
        adj[v].push_back(u);
    }

    void dfs(int u) {
        subtreeSize[u] = 1;

        for (int v : adj[u]) {
            if (subtreeSize[v] == 0) {
                dfs(v);
                subtreeSize[u] += subtreeSize[v];
            } else {
                parent[u] = v;
            }
        }
    }

    void solve() {
        subtreeSize.resize(N, 0);
        parent.resize(N, -1);
        dfs(0);

        vector<long long> invs(N + 1, 0);
        invs[1] = 1;

        for (int i = 2; i < size(invs); ++i) {
            invs[i] = (MODULO - (MODULO / i) * invs[((int) (MODULO % i))] % MODULO) % MODULO;
        }

        vector<long long> facts(N + 1, 0);
        vector<long long> invFacts(N + 1, 0);

        facts[0] = 1;
        invFacts[0] = 1;

        for (int i = 1; i < size(facts); ++i) {
            facts[i] = i * facts[i - 1] % MODULO;
            invFacts[i] = invs[i] * invFacts[i - 1] % MODULO;
        }

        FastFourierTransformModulo ffter((int) MODULO);

        vector<int> p(N + 1, 0);

        for (int v = 0; v < N; ++v)
            if (subtreeSize[v] < N) {
                ++p[subtreeSize[v]];
                ++p[N - subtreeSize[v]];
            }

        for (int i = 0; i <= N; ++i) {
            p[i] = (int) (p[i] * facts[i] % MODULO);
        }

        vector<int> q(N + 1, 0);

        for (int i = 0; i <= N; ++i) {
            q[N - i] = (int) invFacts[i];
        }

        vector<int> prod = ffter.mul(p, q);

        for (int k = 1; k <= N; ++k) {
            long long got = invFacts[k] * prod[N + k] % MODULO;
            long long total = N * facts[N] % MODULO * invFacts[k] % MODULO * invFacts[N - k] % MODULO;
            cout << ((total - got + MODULO) % MODULO) << endl;
        }
    }
};

int main()
{
    int nTest = 1;

    int N = readInt();

    Solver solver;
    solver.initialize(N);

    for (int i = 0; i < N - 1; ++i) {
        int u = readInt() - 1, v = readInt() - 1;
        solver.addEdge(u, v);
    }

    solver.solve();

    // for (int test = 1; test <= nTest; ++test) {
    //     vector<int> a; a.push_back(1); a.push_back(1); a.push_back(1);
    //     vector<int> b; b.push_back(1); b.push_back(1); b.push_back(1);
    //     // The modulo needs to have a special value here: 924844033
    //     FastFourierTransformModulo fft(924844033);
    //     vector<int> c = fft.mul(a, b);
    //     BUG(c);
    // }

    return 0;
}

// Powered by PhoenixAI


Measured memory_bytes: 36544