#include <algorithm>
#include <cmath>
#include <complex>
#include <cstdint>
#include <ios>
#include <iostream>
#include <utility>
#include <vector>

template <typename T>
std::vector<T> fast_fourier_transform(
    const std::vector<T>& vec, std::int32_t inv, const std::vector<T>& rts
) {

    if (std::empty(vec)) {
        return std::vector<T>();
    }

    std::int32_t idx = 0;
    const std::int32_t sz = std::size(vec);
    std::vector vals = vec;

    for (std::int32_t i = 1; i < sz; ++i) {
        std::int32_t bit = sz >> 1;
        while (idx & bit) {
            idx ^= bit;
            bit >>= 1;
        }
        idx |= bit;
        if (i < idx) {
            std::swap(vals[i], vals[idx]);
        }
    }

    for (std::int32_t i = 2; i <= sz; i *= 2) {
        for (std::int32_t j = 0; j < sz; j += i) {
            T cur_rt(1);
            for (std::int32_t k = j; k < j + i / 2; ++k) {
                const T val_1 = vals[k];
                const T val_2 = vals[k + i / 2] * cur_rt;
                vals[k] = val_1 + val_2;
                vals[k + i / 2] = val_1 - val_2;
                cur_rt *= rts[__builtin_ctz(i)];
            }
        }
    }

    if (inv) {
        std::reverse(std::begin(vals) + 1, std::end(vals));
        const T inverse = T(1) / T(sz);
        for (auto& x : vals) {
            x *= inverse;
        }
    }

    return vals;

}

void solve() {

    using cmplx_t = std::complex<double>;

    static const double pi = std::acos(-1);

    std::int32_t m;
    std::int32_t n;

    std::cin >> n >> m;

    std::vector<cmplx_t> a(n + 1);

    for (auto& x : a) {
        std::int64_t coef;
        std::cin >> coef;
        x.real(coef);
    }

    std::vector<cmplx_t> b(m + 1);

    for (auto& x : b) {
        std::int64_t coef;
        std::cin >> coef;
        x.real(coef);
    }

    const std::int32_t lg = 31 - __builtin_clz((n + m + 1) * 2 - 1);

    std::vector<cmplx_t> rts(lg + 1);
    const std::int32_t sz = 1 << lg;

    for (std::int32_t i = 0; i <= lg; ++i) {
        rts[i] = std::polar(1.0, pi * 2 / (1 << i));
    }

    a.resize(sz);
    b.resize(sz);

    a = fast_fourier_transform(a, 0, rts);
    b = fast_fourier_transform(b, 0, rts);

    std::vector<cmplx_t> c(sz);

    for (std::int32_t i = 0; i < sz; ++i) {
        c[i] = a[i] * b[i];
    }

    c = fast_fourier_transform(c, 1, rts);

    for (std::int32_t i = 0; i <= n + m; ++i) {
        std::cout << std::lround(std::real(c[i])) << (i < n + m ? ' ' : '\n');
    }

}

int main() {

    std::cin.tie(nullptr);

    std::ios_base::sync_with_stdio(false);

    solve();

    return 0;

}