#include <bits/stdc++.h>

using namespace std;

const int max_lev = 20, mod = 998244353;

template<int mod, int max_lev>
struct NTT {
    static const int max_n = 1 << max_lev;

    int roots[2][max_lev];
    int rev[max_n], buf1[max_n], buf2[max_n], bufpw[max_n];

    NTT() {
        int root = find_root();
        int rroot = power(root, mod - 2);
        roots[0][0] = root;
        roots[1][0] = rroot;
        for (int i = 1; i < max_lev; ++i) {
            roots[0][i] = mul(roots[0][i - 1], roots[0][i - 1]);
            roots[1][i] = mul(roots[1][i - 1], roots[1][i - 1]);
        }
        for (int i = 1; i < max_n; ++i) {
            rev[i] = (rev[i / 2] / 2) + ((i & 1) << (max_lev - 1));
        }
    }

    static inline void inc(int &x, int y) {
        x += y;
        if (x >= mod) {
            x -= mod;
        }
    }

    static inline int mul(int x, int y) {
        return (1LL * x * y) % mod;
    }

    static int power(int x, int y) {
        if (y == 0) {
            return 1;
        }
        if (y % 2 == 0) {
            return power(mul(x, x), y / 2);
        }
        return mul(x, power(x, y - 1));
    }

    static int find_root() {
        for (int root = 2; ; ++root) {
            if (power(root, max_n) == 1) {
                int cur = 1;
                bool ok = true;
                for (int i = 1; i < max_n; ++i) {
                    cur = mul(cur, root);
                    if (cur == 1) {
                        ok = false;
                        break;
                    }
                }
                if (ok) {
                    return root;
                }
            }
        }
    }

    void fft(int *a, const int *roots, int lg) {
        const int n = 1 << lg;
        for (int i = 0; i < n; ++i) {
            int r = (rev[i] >> (max_lev - lg)) & (n - 1);
            if (i < r) {
                swap(a[i], a[r]);
            }
        }
        int pos = max_lev - 1;
        for (int st = 1; st < n; st *= 2) {
            int cur = 1;
            for (int i = 0; i < st; ++i) {
                bufpw[i] = cur;
                cur = mul(cur, roots[pos]);
            }
            --pos;
            for (int i = 0; i < n; i += 2 * st) {
                int *curpw = bufpw;
                for (int j = i; j < i + st; ++j) {
                    int y = mul(*curpw++, a[j + st]);
                    a[j + st] = a[j];
                    inc(a[j + st], mod - y);
                    inc(a[j], y);
                }
            }
        }
    }

    vector<int> product(const vector<int> &a, const vector<int> &b) {
        int sz = a.size() + b.size() - 1;
        int n = 1, rn = 1, lg = 0;
        while (n < sz) {
            n *= 2;
            rn = mul(rn, (mod + 1) / 2);
            ++lg;
        }
        memcpy(buf1, a.data(), 4 * a.size());
        memset(buf1 + a.size(), 0, 4 * (n - a.size()));
        memcpy(buf2, b.data(), 4 * b.size());
        memset(buf2 + b.size(), 0, 4 * (n - b.size()));
        fft(buf1, roots[0], lg);
        fft(buf2, roots[0], lg);
        for (int i = 0; i < n; ++i) {
            buf1[i] = mul(buf1[i], buf2[i]);
        }
        fft(buf1, roots[1], lg);
        vector<int> ans(sz);
        for (int i = 0; i < sz; ++i) {
            ans[i] = mul(buf1[i], rn);
        }
        return ans;
    }

    vector<int> square(const vector<int> &a) {
        int sz = a.size() + a.size() - 1;
        int n = 1, rn = 1, lg = 0;
        while (n < sz) {
            n *= 2;
            rn = mul(rn, (mod + 1) / 2);
            ++lg;
        }
        memcpy(buf1, a.data(), 4 * a.size());
        memset(buf1 + a.size(), 0, 4 * (n - a.size()));
        fft(buf1, roots[0], lg);
        for (int i = 0; i < n; ++i) {
            buf1[i] = mul(buf1[i], buf1[i]);
        }
        fft(buf1, roots[1], lg);
        vector<int> ans(sz);
        for (int i = 0; i < sz; ++i) {
            ans[i] = mul(buf1[i], rn);
        }
        return ans;
    }
};

NTT<mod, max_lev> ntt;

int main() {
    //freopen("input.txt", "r", stdin);
    //freopen("output.txt", "w", stdout);
    int n, m;
    scanf("%d%d", &n, &m);
    vector<int> a(n), b(m);
    for (int &x : a) {
        scanf("%d", &x);
    }
    for (int &x : b) {
        scanf("%d", &x);
    }
    vector<int> c = ntt.product(a, b);
    for (int x : c) {
        printf("%d ", x);
    }
    puts("");
    return 0;
}


Measured memory_bytes: 33340