//pragma
//#pragma GCC optimize("Ofast")
//#pragma GCC optimize("unroll-loops")

#include <bits/stdc++.h>

#define YOU using
#define DONT namespace
#define SAY std

YOU DONT SAY;

typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
typedef pair<ll,int> pli;
typedef pair<int,ll> pil;
typedef vector<int> vi;
typedef vector<pii> vii;
typedef vector<pll> vll;

#define REPP(i,a,b,d) for(int i=a;i<=b;i+=d)
#define REP(i,a,b) REPP(i,a,b,1)
#define REVV(i,a,b,d) for(int i=a;i>=b;i-=d)
#define REV(i,a,b) REVV(i,a,b,1)

#define FOR(i,a) for(int i=0; i<a; i++)
#define FORD(i,a) for(int i=(int)a-1; i>=0; i--)

#define pb push_back
#define F first
#define S second

const int OO = 1e9;
const ll INF = 1e18;

const int irand(int lo,int hi){
    return ((double)rand()/(RAND_MAX + 1.0)) * (hi-lo+1) + lo;
}

const ll lrand(ll lo,ll hi){
    return ((double)rand()/(RAND_MAX + 1.0)) * (hi-lo+1) + lo;
}

#define getc getchar
template<typename T>
T getnum(){
    int sign = 1;
    T ret = 0;
    char c;

    do{
        c = getc();
    }while(c == ' ' || c == '\n');
    if(c == '-')sign = -1;
    else ret = c-'0';
    while(1){
        c = getc();
        if(c < '0' || c > '9')break;
        ret = 10*ret + c-'0';
    }
    return sign * ret;
}

inline void ini(int& x){
    x = getnum<int>();
}

inline void scani(int& x){
    scanf("%d",&x);
}

//end of macro

/*
input a, a vector representation of polynomial, output a as point representation. Put sign=-1 for inverse.
NTT -> integer FFT with modulo
 */

/*
For NTT, let p be modulo prime
p = 2^k * c + 1
need: size of polynom <= 2^k
find r so that r^1 .. r^p-1 distinct <- call prr

change for the following
int theta = expmod(prr, (MOD-1)/n); // expmod->exponent
if(sign == -1)theta = expmod(theta, MOD-2);
    w = expmod(theta, irev) // can be saved to array
don’t forget divmod and other mods
*/

const ll MOD = 924844033;
inline ll addmod(ll a, ll b){
    if(a+b<MOD)return a+b;
    return a+b-MOD;
}
inline ll submod(ll a, ll b){
    return addmod(a, MOD-b);
}
inline ll mulmod(ll a, ll b){
    return (a*b)%MOD;
}
inline ll expmod(ll a, ll e){
    ll ret = 1;
    while(e){
        if(e&1)ret = mulmod(ret, a);
        a = mulmod(a, a);
        e >>= 1;
    }
    return ret;
}
inline ll divmod(ll a, ll b){
    return mulmod(a, expmod(b, MOD-2));
}

const int prr = 5;
void FFT(vector<int>& a, int sign = 1) {
    int n = a.size(); // n should be a power of two
    int theta = expmod(prr, (MOD-1)/n);
    if(sign == -1)theta = expmod(theta, MOD-2);

    for(int i = 0, j = 1; j < n - 1; ++j) {
        for(int k = n >> 1; k > (i ^= k); k >>= 1);
        if(j < i) swap(a[i], a[j]);
    }
    for(int m, mh = 1; (m = mh << 1) <= n; mh = m) {
        int irev = 0;
        for(int i = 0; i < n; i += m) {
            int  w = expmod(theta, irev);
            for(int k = n >> 2; k > (irev ^= k); k >>= 1);
            for(int j = i; j < mh + i; ++j) {
                int k = addmod(j, mh);
                int x = submod(a[j], a[k]);
                a[j] = addmod(a[j], a[k]);
                a[k] = mulmod(w, x);
            }
        }
    }
    if(sign == -1) FOR(i,n)a[i] = divmod(a[i], n);
}

void vector_multiply(vector<int>& res, vector<int>& a, vector<int>& b){ // multiplies, stores to a
    res.clear();
    int n = a.size() + b.size() - 1;
    for(int i=1; i<n; i<<=1)if(n&i)n += i;
    a.resize(n);
    b.resize(n);

    FFT(a);
    FFT(b);
    FOR(i,n)res.pb(mulmod(a[i], b[i]));
    FFT(res, -1);
}

// MOD as prime modulo
// int primitive_root () {
//     vector<int> fact;
//     int phi = MOD-1,  n = phi;
//     for (int i=2; i*i<=n; ++i)
//         if (n % i == 0) {
//             fact.push_back (i);
//             while (n % i == 0)
//                 n /= i;
//         }
//     if (n > 1)
//         fact.push_back (n);

//     for (int res=2; res<=MOD; ++res) {
//         bool ok = true;
//         for (size_t i=0; i<fact.size() && ok; ++i)
//             ok &= expmod (res, phi / fact[i]) != 1;
//         if (ok)  return res;
//     }
//     return -1;
// }

const int N = 2e5 + 5;
int n;
vi lst[N];

int fac[N];
inline int C(int n, int r){
    if(n < r)return 0;
    return divmod(fac[n], mulmod(fac[r], fac[n-r]));
}

vi vl;
int sz[N];
int idfs(int now, int par){
    sz[now] = 1;
    for(auto to : lst[now]){
        if(to == par)continue;
        idfs(to, now);
        sz[now] += sz[to];
    }

    if(par != -1)vl.pb(sz[now]);
}

int cnt[N]; // count array of vl
int sg[N]; // sg[k] = sum of cnt[i] * C(i, k), or simply sum of C(vl[i], k)
vi f, g, fg;
void gen_sg(){
    // printf("generate sg\n");
    // for(auto x : vl)printf("vl %d\n",x);
    memset(cnt, 0, sizeof cnt);
    for(auto x : vl){
        cnt[x]++;
    }
    // we will shift g(x) by n, so read x^(k+n) from f(x)*g(x)
    // therefore size of f(x) and g(x) will be n
    f.clear(); g.clear();
    REP(i,0,n){
        f.pb(mulmod(cnt[i], fac[i]));
        g.pb(divmod(1, fac[n-i]));
    }
    vector_multiply(fg, f, g);
    REP(i,1,n){
        sg[i] = fg[i+n];
        sg[i] = divmod(sg[i], fac[i]);
    }
    // REP(i,1,n){
    //     printf("%d\n",sg[i]);
    // }
}

int ans[N];

int main(){
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    #define endl '\n'
    cout.setf(ios::fixed);
    cout.setf(ios::showpoint);
    cout.precision(10);

    fac[0] = 1;
    REP(i,1,N-1)fac[i] = mulmod(fac[i-1], i);

    cin>>n;
    REP(i,2,n){
        int a,b;
        cin>>a>>b;
        lst[a].pb(b);
        lst[b].pb(a);
    }

    idfs(1, -1);

    // there are n-1 edges, but, multiplied by n because number of nodes = edges+1
    REP(i,1,n){
        ans[i] = mulmod(n, C(n, i));
        // printf("init %d\n",ans[i]);
    }

    gen_sg();
    REP(i,1,n){
        ans[i] = submod(ans[i], sg[i]);
    }

    for(auto& x : vl){
        x = n-x;
    }
    gen_sg();
    REP(i,1,n){
        ans[i] = submod(ans[i], sg[i]);
    }

    REP(i,1,n){
        cout << ans[i] << endl;
    }

    return 0;
}


Measured memory_bytes: 34700