#include <bits/stdc++.h>

const int N = 1e6 + 50;
const int mod = 998244353;
const int g = 3;

inline int inc(int x, int y) { x += y - mod; return x + (x >> 31 & mod); }
inline int dec(int x, int y) { x -= y; return x + (x >> 31 & mod); }
inline int mul(int x, int y) { return 1ll * x * y % mod; }
inline int fastpow(int x, int p)
{
	int r = 1;
	while (p)
	{
		if (p & 1) r = mul(r, x);
		x = mul(x, x);
		p >>= 1;
	}
	return r;
}

struct NTT
{
	int omega[N], omegaInv[N], rev[N], len, k;
	inline void init(int n)
	{
		len = 1, k = 0;
		while (len <= n) len <<= 1, ++k;
		for (int i = 0; i < len; ++i) rev[i] = (rev[i >> 1] >> 1) | ((i & 1) << (k - 1));
		const int t = fastpow(g, (mod - 1) / len);
		omega[0] = omegaInv[0] = 1;
		for (int i = 1; i < len; ++i) omega[i] = omegaInv[len - i] = mul(omega[i - 1], t);
	}
	inline void DFT(int *a, const int *w)
	{
		for (int i = 1; i < len; ++i) if (i < rev[i]) std::swap(a[i], a[rev[i]]);
		for (int h = 1; h < len; h <<= 1)
			for (int t = len / (h << 1), j = 0; j < len; j += (h << 1))
			{
				const int *wn = w; int *x = a + j, *y = a + j + h;
				for (int i = j; i < j + h; ++i)
				{
					int _1 = *x, _2 = mul(*y, *wn);
					*x++ = inc(_1, _2);
					*y++ = dec(_1, _2);
					wn += t;
				}
			}
		if (w == omegaInv)
		{
			const int t = mod - (mod - 1) / len;
			for (int i = 0; i < len; ++i) a[i] = mul(a[i], t);
		}
	}
	inline void operator()(std::vector<int> &_, int op)
	{
		if (_.size() < len) _.resize(len);
		if (op == 1) DFT(_.data(), omega);
		else DFT(_.data(), omegaInv);
		assert(_.size() >= len);
	}
} ntt;
struct Complex
{
	long double x, y;
	Complex(long double x = 0, long double y = 0) : x(x), y(y) {}
};
Complex operator+(const Complex &u, const Complex &v) { return Complex(u.x + v.x, u.y + v.y); }
Complex operator-(const Complex &u, const Complex &v) { return Complex(u.x - v.x, u.y - v.y); }
Complex operator*(const Complex &u, const Complex &v) { return Complex(u.x * v.x - u.y * v.y, u.x * v.y + u.y * v.x); }

struct FFT
{
	int rev[N], len, k;
	const long double pi = acosl(-1.0);
	Complex omega[N], omegaInv[N];	
	inline void init(int n)
	{
		len = 1, k = 0;
		while (len <= n) len <<= 1, ++k;
		for (int i = 0; i < len; ++i) rev[i] = (rev[i >> 1] >> 1) | ((i & 1) << (k - 1));
		Complex t(cosl(2.0 * pi / len), sinl(2.0 * pi / len));
		omega[0] = omegaInv[0] = Complex(1.0, 0.0);
		for (int i = 1; i < len; ++i) 
			if (i & 32) omega[i] = omegaInv[len - i] = omega[i - 1] * t;
			else omega[i] = omegaInv[len - i] = Complex(cosl(2.0 * pi * i / len), sinl(2.0 * pi * i / len));

	}
	inline void DFT(Complex *a, const Complex *w)
	{
		for (int i = 1; i < len; ++i) if (i < rev[i]) std::swap(a[i], a[rev[i]]);
		for (int h = 1; h < len; h <<= 1)
			for (int t = len / (h << 1), j = 0; j < len; j += (h << 1))
			{
				const Complex *wn = w; Complex *x = a + j, *y = a + j + h;
				for (int i = j; i < j + h; ++i)
				{
					Complex _1 = *x, _2 = *y * *wn;
					*x++ = _1 + _2;
					*y++ = _1 - _2;
					wn += t;
				}
			}
		if (w == omegaInv)
		{
			for (int i = 0; i < len; ++i) a[i].x /= len;
		}
	}
	inline void operator()(std::vector<Complex> &_, int op)
	{
		if (_.size() < len) _.resize(len);
		if (op == 1) DFT(_.data(), omega);
		else DFT(_.data(), omegaInv);
		assert(_.size() >= len);
	}
} fft;

struct Poly
{
	std::vector<int> _;
	Poly(){}
	Poly(const std::vector<int> &_) : _(_) {}
	inline int& operator[](int k)
	{
		if (_.size() <= k) _.resize(k + 1);
		return _[k];
	}
	inline int operator[](int k) const
	{
		if (_.size() <= k) return 0;
		return _[k];
	}
	inline int deg() const
	{
		return (int)_.size() - 1;
	}
};

template <int T>
struct fast_io
{
	char p[T], q[T], * p1, * p2, * q1, * q2;
	fast_io()
	{
		p1 = p2 = p;
		q1 = q, q2 = q + T;
	}
	inline char gc()
	{
		return p1 == p2 && (p2 = (p1 = p) + fread(p, 1, T, stdin), p1 == p2) ? EOF : *p1++;
	}
	inline void pc(char c)
	{
		if (q1 == q2) q2 = (q1 = q) + fwrite(q, 1, T, stdout);
		*q1++ = c;
	}
	~fast_io()
	{
		fwrite(q, 1, q1 - q, stdout);
	}
};
fast_io<1 << 20> io;
inline int read()
{
	int res = 0;
	char ch;
	do ch = io.gc(); while (ch < 48 || ch > 57);
	do res = res * 10 + ch - 48, ch = io.gc(); while (ch >= 48 && ch <= 57);
	return res;
}
inline void put(int64_t x)
{
	if (x < 0) io.pc('-'), x = -x;
	if (x >= 10) put(x / 10);
	io.pc(48 + x % 10);
}
inline void output(int64_t x, char ch = ' ')
{
	put(x);
	io.pc(ch);
}

inline Poly operator*(const Poly &A, const Poly &B)
{
	int d1 = A.deg(), d2 = B.deg();
	fft.init(d1 + d2 + 1);
	std::vector<Complex> a(fft.len), b(fft.len), c(fft.len);
	for (int i = 0; i <= d1; ++i) a[i] = Complex(A._[i], 0.0);
	for (int i = 0; i <= d2; ++i) b[i] = Complex(B._[i], 0.0);
	fft(a, 1), fft(b, 1);
	for (int i = 0; i < fft.len; ++i) c[i] = a[i] * b[i];
	fft(c, -1);
	std::vector<int> d(d1 + d2 + 1);
	for (int i = 0; i <= d1 + d2; ++i) d[i] = (long long)(c[i].x + 0.5) % mod;
	return Poly(d);
}
int main()
{
	Poly A, B;
	int n = read(), m = read();
	for (int i = 0; i <= n; ++i) A[i] = read();
	for (int i = 0; i <= m; ++i) B[i] = read();
	Poly C = A * B;
	for (int i = 0; i <= n + m; ++i) output(C[i]);
	return 0;
}