Language: C++

#include <smmintrin.h>
#include <immintrin.h>
#pragma GCC target("avx2")
#pragma GCC target("fma")
#pragma GCC optimize("Ofast")

#include <stdio.h>  
#include <algorithm>  
#include <assert.h>
#include <bitset>
#include <cmath>  
#include <complex>  
#include <deque>  
#include <functional>  
#include <iostream>  
#include <limits.h>  
#include <map>  
#include <math.h>  
#include <queue>  
#include <set>  
#include <stdlib.h>  
#include <string.h>  
#include <string>  
#include <time.h>  
#include <unordered_map>  
#include <unordered_set>  
#include <vector>  

#pragma warning(disable:4996)  
#pragma comment(linker, "/STACK:336777216")  
using namespace std;

#define mp make_pair  
#define Fi first  
#define Se second  
#define pb(x) push_back(x)  
#define szz(x) ((int)(x).size())  
#define rep(i, n) for(int i=0;i<n;i++)  
#define all(x) (x).begin(), (x).end()  
#define ldb ldouble  

typedef unsigned int uint;
typedef tuple<int, int, int> t3;
typedef long long ll;
typedef unsigned long long ull;
typedef double db;
typedef long double ldb;
typedef pair <int, int> pii;
typedef pair <ll, ll> pll;
typedef pair <ll, int> pli;
typedef pair <db, db> pdd;

int IT_MAX = 1 << 19;
const ll MOD = 1000000007;
const int INF = 0x3f3f3f3f;
const ll LL_INF = 0x3f3f3f3f3f3f3f3f;
const db PI = acos(-1);
const db ERR = 1e-10;

namespace FFT{
	const int P = 924844033, R = 5;
	const int SZ = 19, N = 1 << SZ;

	uint Pow(int x, int y) {
		int r = 1;
		while (y) {
			if (y & 1) r = (ll) r * x % P;
			x = (ll) x * x % P;
			y >>= 1;
		}
		return r;
	}

	const uint RP = Pow((1ll<<32)%P, P-2), MP = P-2; // MP = P^-1 mod 2^32
	const uint QP = ((ll)Pow(R, (P-1)/4) << 32) % P;
	const uint OP = ((ll)Pow(R, (P-1)/8) << 32) % P; 
	const uint RQP = ((ll)Pow(R, (P-1)/4*3) << 32) % P;
	const uint ROP = ((ll)Pow(R, (P-1)/8*7) << 32) % P; 
	uint A[N] __attribute__ ((aligned (0x100)));
	uint B[N] __attribute__ ((aligned (0x100)));
	__m256i Pa;

	void init(){ Pa = _mm256_set1_epi32(P); }

	inline uint fit(uint a){ return a >= P? a-P : a; }

	__m256i avx_add(__m256i a, __m256i b){
		__m256i c = _mm256_add_epi32(a, b);
		__m256i d = _mm256_sub_epi32(c, Pa);
		return _mm256_min_epu32(c, d);
	}

	__m256i avx_sub(__m256i a, __m256i b){
		__m256i c = _mm256_sub_epi32(a, b);
		__m256i d = _mm256_add_epi32(c, Pa);
		return _mm256_min_epu32(c, d);
	}

	__m256i avx_fit(__m256i a){
		__m256i b = _mm256_sub_epi32(a, Pa);
		return _mm256_min_epu32(a, b);
	}

	uint my_mul(uint a, uint b){
		return fit(((ull)a*b + (ull)P*(a*b*MP)) >> 32);
	}

	__m256i avx_mul(__m256i a, __m256i b){
		__m256i res[2];
		__m256i p = _mm256_mullo_epi32(_mm256_mullo_epi32(a, b), _mm256_set1_epi32(MP));

		__m256i ax = _mm256_shuffle_epi32(a, 0x50);
		__m256i bx = _mm256_shuffle_epi32(b, 0x50);
		__m256i px = _mm256_shuffle_epi32(p, 0x50);
		__m256i c = _mm256_mul_epu32(ax, bx);
		__m256i f = _mm256_mul_epu32(px, Pa);

		res[0] = _mm256_add_epi64(c, f);

		ax = _mm256_shuffle_epi32(a, 0xfa);
		bx = _mm256_shuffle_epi32(b, 0xfa);
		px = _mm256_shuffle_epi32(p, 0xfa);
		c = _mm256_mul_epu32(ax, bx);
		f = _mm256_mul_epu32(px, Pa);

		res[1] = _mm256_add_epi64(c, f);

		return avx_fit(_mm256_hadd_epi32(res[0], res[1]));
	}

	inline void run(uint* A, bool rv) {
		int j = 0, k = 0;
		A[0] = ((ull)A[0] << 32) % P; // Encode
		for (int i = 1; i < N; i++) {
			for (k = N >> 1; j >= k; k >>= 1) j -= k;
			j += k;
			if (i < j) swap(A[i], A[j]);
			A[i] = ((ull)A[i] << 32) % P; // Encode
		}

		uint x = ((ull)Pow(rv ? Pow(R, P - 2) : R, P >> 3) << 32) % P;
		for (int j = 0; j < N; j += 8) {
			uint y = (1ll<<32) % P;
			uint v[8], z;
			auto f = [](uint &v1, uint &v2, uint a, uint b){ v1 = fit(a+b); v2 = fit(a-b+P); };

			for(int t = 0; t < 8; t++) v[t] = A[j+t];

			z = my_mul(y, y); z = my_mul(z, z);
			for(int k = 0; k < 8; k += 2)
				f(v[k], v[k+1], v[k], my_mul(v[k+1], z));

			z = my_mul(y, y);
			for(int k = 0; k < 2; k ++, z = my_mul(z, rv? RQP : QP))
				f(v[k], v[k+2], v[k], my_mul(v[k+2], z));

			z = my_mul(y, y);
			for(int k = 4; k < 6; k ++, z = my_mul(z, rv? RQP : QP))
				f(v[k], v[k+2], v[k], my_mul(v[k+2], z));

			z = y;
			for(int k = 0; k < 4; k ++, z = my_mul(z, rv? ROP : OP))
				f(v[k], v[k+4], v[k], my_mul(v[k+4], z));

			for(int t = 0; t < 8; t++) A[j+t] = v[t];

			y = my_mul(y, x);
		}
		// */
		//*
		for (int i = 8; i < N; i <<= 1) {
			uint t = ((ull)Pow(rv ? Pow(R, P - 2) : R, P / i >> 1) << 32) % P;
			uint u = (1ll << 32) % P;

			__m256i yi, x;
			for(int j = 0; j < 8; j++, u = my_mul(u, t)) yi = _mm256_insert_epi32(yi, u, j);
			x = _mm256_set1_epi32(u);

			for (int j = 0; j < N; j += i << 1) {
				__m256i y = yi;
				for(int l = 0; l < i; l += 8){
					__m256i v[2];
					auto f = [](__m256i &v1, __m256i &v2, __m256i a, __m256i b){
						v1 = avx_add(a, b);
						v2 = avx_sub(a, b);
					};

					for(int t = 0; t < 2; t++)
						v[t] = _mm256_stream_load_si256((__m256i *)(A+j+i*t+l));

					f(v[0], v[1], v[0], avx_mul(v[1], y));

					for(int t = 0; t < 2; t++)
						_mm256_store_si256((__m256i *)(A+j+i*t+l), v[t]);

					y = avx_mul(y, x);
				}
			}
		} // */
		if(rv){
			uint v = ((ull)Pow(N, P - 2) << 32) % P;
			for (int i = 0; i < N; i++) A[i] = my_mul(A[i], v);
		}
		for(int i = 0; i < N; i++) A[i] = (ull)A[i] * RP % P; // Decode
	}
	
	void runA(bool rv){ return run(A, rv); }
	void runB(bool rv){ return run(B, rv); }

	void multiplication(){
		runA(false);
		runB(false);
		for(int i = 0; i < N; i++) A[i] = (ll)A[i] * B[i] % P;
		runA(true);
	}
}

const int MX = 200005;
const int MM = 924844033;

int cnt[MX];
ll I[MX];
vector<int> T[MX];

void dfs(int x, int p = -1){
	cnt[x]++;
	for(int c : T[x]){
		if( c == p ) continue;
		dfs(c, x);
		cnt[x] += cnt[c];
	}
}

int ans[1<<21];
int main()
{
	FFT::init();
	int N, K;
	scanf("%d", &N);

	I[1] = 1;
	for(int i = 2; i <= N; i++) I[i] = (MM - MM/i) * I[MM%i] % MM;

	for(int i = 1; i < N; i++){
		int a, b;
		scanf("%d%d", &a, &b);
		T[a].push_back(b);
		T[b].push_back(a);
	}
	dfs(1);

	uint* F = FFT::A, *G = FFT::B;

	ans[0] = G[0] = 1;
	for(int i = 1; i <= N; i++) ans[i] = G[i] = G[i-1] * I[i] % MM;

	F[0] += N;
	for(int c : T[1]){
		F[N-cnt[c]] -= 1;
	}
	for(int i = 2; i <= N; i++){
		int mx = 0;
		for(int c : T[i]) mx = max(mx, cnt[c]);
		for(int c : T[i]){
			if( cnt[c] != mx ){
				F[N-cnt[c]] -= 1;
			}
		}
		F[cnt[i]] -= 1;
	}

	ll mul = 1;
	for(int i = 0; i <= N; i++){
		F[N-i] = mul * (MM+F[N-i]) % MM;
		mul = mul * (i+1) % MM;
	}
	FFT::multiplication();
	
	for(int i = N-1; i >= 0; i--) printf("%lld\n", (ll)F[i] * ans[N-i] % MM);
}



Compiler output:
In file included from /usr/include/c++/14/string:43,
                 from /usr/include/c++/14/bitset:52,
                 from a.cc:10:
/usr/include/c++/14/bits/allocator.h: In destructor 'std::_Vector_base<int, std::allocator<int> >::_Vector_impl::~_Vector_impl()':
/usr/include/c++/14/bits/allocator.h:182:7: error: inlining failed in call to 'always_inline' 'std::allocator< <template-parameter-1-1> >::~allocator() noexcept [with _Tp = int]': target specific option mismatch
  182 |       ~allocator() _GLIBCXX_NOTHROW { }
      |       ^
In file included from /usr/include/c++/14/vector:66,
                 from /usr/include/c++/14/functional:64,
                 from a.cc:14:
/usr/include/c++/14/bits/stl_vector.h:132:14: note: called from here
  132 |       struct _Vector_impl
      |              ^~~~~~~~~~~~