#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <cstdio>
#include <cstring>
#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;
        if (n_ < 4) return;

        w_.resize(n_ * 2);

        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_];
            w[0] = 1;
            for (int i = 1; i < n_ / 2; i++) {
                w[i] = mul(w[i - 1], w1);
            }
            for (int i = 0; i < n_ / 2; i++) {
                w[n_ / 2 + i] = w[i * 2];
            }
            w1 = mul(w_[n_ / 2 - 1], mul(w_[n_ / 4], w_[n_ / 4]));
        }
    }
    static int inv(int n) {
        return P - (P - 1) / n;
    }
    static int get_2(int n) {
        int r = 1;
        while (r < n) r *= 2;
        return r;
    }
    FMT(int n) : 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 i, int n, int sign) {
        if (n > 2) {
            if (sign > 0) {
                fmt_f(n, &data_[i], &w_[n_ * 1 - n]);
            } else {
                fmt_t(n, &data_[i], &w_[n_ * 2 - n]);
            }
        } else if (n == 2) {
            fmt_2(&data_[i]);
        }
    }
    void conv(int i0, int i1, int n) {
        fmt(i0, n, +1);
        fmt(i1, n, +1);
        for (int i = 0; i < n; i++) {
            data_[i0 + i] = FMT::mul(data_[i0 + i], data_[i1 + i]);
        }
        fmt(i0, n, -1);
        const int n_inv = P - (P - 1) / n;
        for (int i = 0; i < n; i++) {
            data_[i0 + i] = FMT::mul(data_[i0 + i], n_inv);
            data_[i1 + i] = 0;
        }
    }

private:
    static void fmt_f(int n, uint32_t *p, uint32_t *w) {
        const int m = n / 2;

        for (int i = 0; i < m; i++) {
            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[i]);
            p[i] = t0;
            p[j] = t1;
        }

        if (m == 2) {
            fmt_2(p);
            fmt_2(p + 2);
        } else {
            fmt_f(m, p, w + m);
            fmt_f(m, p + m, w + m);
        }
    }
    static void fmt_t(int n, uint32_t *p, uint32_t *w) {
        const int m = n / 2;

        if (m == 2) {
            fmt_2(p);
            fmt_2(p + 2);
        } else {
            fmt_t(m, p, w + m);
            fmt_t(m, p + m, w + m);
        }

        for (int i = 0; i < m; i++) {
            int j = i + m;
            const uint32_t t0 = mul(w[i], p[j]);
            p[j] = sub(p[i], t0);
            p[i] = add(p[i], t0);
        }
    }
    static void fmt_2(uint32_t *p) {
        const uint32_t t0 = add(p[0], p[1]);
        const uint32_t t1 = sub(p[0], p[1]);
        p[0] = t0;
        p[1] = t1;
    }

    static inline int n_;
    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 m = (n + 2) / 3;
    int l = FMT::get_2(m * 8);
    FMT::init(l / 2);

    FMT p(l);

    for (int i = 0; i < m * 8; i += 8) {
        ll b[3];
        for (int j = 0; j < 3; j++) {
            ll a;
            if (n-- > 0) b[j] = (cin >> a, (a - 1) % FMT::P);
        }
        if (n >= 0) {
            p[i + 0] = b[0] * b[1] % FMT::P * b[2] % FMT::P;
            p[i + 1] = ((b[0] + b[1]) * b[2] + b[0] * b[1]) % FMT::P;
            p[i + 2] = (b[0] + b[1] + b[2]) % FMT::P;
            p[i + 3] = 1;
        } else if (n == -1) {
            p[i + 0] = b[0] * b[1] % FMT::P;
            p[i + 1] = (b[0] + b[1]) % FMT::P;
            p[i + 2] = 1;
        } else if (n == -2) {
            p[i + 0] = b[0];
            p[i + 1] = 1;
        }
    }
    for (int i = m * 8; i < l; i += 8) {
        p[i] = 1;
    }

    for (int k = 8; k < l; k *= 2) {
        for (int i = 0; i < l; i += k * 2) {
            p.conv(i, i + k, k);
        }
    }

    while (q--) {
        int b;
        cin >> b;
        cout << p[b] << '\n';
    }

    return 0;
}