#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <cstring>
#include <cstdlib>
#include <cmath>
using namespace std;
using ll = long long;

class FMT {
public:
    static constexpr uint32_t W = 31, P = (119 << 23) + 1;

    static void init(int n) {
        if ((n & -n) != n || n < 1) throw;

        n_ = n;
        n_inv_ = P - P / n_;
        if (n_ < 2) return;

        w_.resize(n_);

        uint32_t w1 = W;
        for (int n = n_; n < 1 << 23; n *= 2) {
            w1 = mul(w1, w1);
        }

        for (int l = 0; l < 2; l++) {
            uint32_t *w = &w_[l * n_ / 2];
            w[0] = 1;
            for (int i = 1; i < n_ / 2; i++) {
                w[i] = mul(w[i - 1], w1);
            }
            w1 = mul(w_[n_ / 2 - 1], mul(w_[n_ / 4], w_[n_ / 4]));
        }
    }
    static int get_2(int n) {
        int r = 1;
        while (r < n) r *= 2;
        return r;
    }
    FMT() : data_(n_, 0) {}

    static uint32_t add(uint32_t a1, uint32_t a2) {
        const uint32_t t = a1 + a2;
        return t < P ? t : t - P;
    }
    static uint32_t sub(uint32_t a1, uint32_t a2) {
        const uint32_t t = a1 - a2;
        return t < P ? t : t + P;
    }
    static uint32_t mul(uint32_t a1, uint32_t a2) {
        return (uint64_t)a1 * a2 % P;
    }

    uint32_t &operator[](size_t i) {
        return data_[i];
    }
    void fmt(int sign) {
        if (n_ > 1) {
            if (sign > 0) {
                fmt_f(n_, &data_[0], &w_[0]);
            } else {
                fmt_t(n_, &data_[0], &w_[n_ / 2]);
            }
        }
    }
    void conv(FMT &b) {
        fmt(+1);
        if (this != &b) b.fmt(+1);
        for (int i = 0; i < n_; i++) {
            data_[i] = mul(data_[i], b.data_[i]);
        }
        fmt(-1);
        for (int i = 0; i < n_; i++) {
            data_[i] = mul(data_[i], n_inv_);
        }
    }

private:
    static void fmt_f(int n, uint32_t *p, uint32_t *w) {
        for (int m = n / 2; m > 0; m /= 2) {
            const int s = n / (m * 2);
            for (int l = 0; l < n; l += m * 2) {
                for (int k = 0; k < m; k++) {
                    const int i = k + l;
                    const int j = i + m;
                    const uint32_t t0 = add(p[i], p[j]);
                    const uint32_t t1 = mul(p[i] - p[j] + P, w[k * s]);
                    p[i] = t0;
                    p[j] = t1;
                }
            }
        }
    }
    static void fmt_t(int n, uint32_t *p, uint32_t *w) {
        for (int m = 1; m < n; m *= 2) {
            const int s = n / (m * 2);
            for (int l = 0; l < n; l += m * 2) {
                for (int k = 0; k < m; k++) {
                    const int i = k + l;
                    const int j = i + m;
                    const uint32_t t0 = mul(w[k * s], p[j]);
                    p[j] = sub(p[i], t0);
                    p[i] = add(p[i], t0);
                }
            }
        }
    }

    static inline int n_;
    static inline uint32_t n_inv_;
    static inline vector<uint32_t> w_;
    vector<uint32_t> data_;
};

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);

    int n, q;
    cin >> n >> q;

    int k = FMT::get_2(n) * 2;
    FMT::init(k);
    FMT p[2];

    for (int i = 0; i < n; i++) {
        int a;
        cin >> a;

        p[0][i] = a;
    }

    for (int j = 0; j < q; j++) {
        int r;
        cin >> r;

        if (r > 0) r = n - r;
        p[1][r]++;
    }
    for (int i = 1; i < n; i++) {
        p[1][i + k - n] = p[1][i];
    }

    p[0].conv(p[1]);

    for (int i = 0; i < n; i++) {
        cout << p[0][i] << " \n"[i == n - 1];
    }

    return 0;
}