#include <bits/stdc++.h>

using namespace std;

const int N = 5e4 + 5, LIM = 1e6, P = 998244353, G = 3, iG = (P + 1) / G;

int inv[LIM + 5];

int ksm(int x, int y = P - 2) {
    if (x <= LIM && y == P - 2) {
        return inv[x];
    }
    int res = 1;
    while (y) {
        if (y & 1) {
            res = 1ll * res * x % P;
        }
        x = 1ll * x * x % P;
        y >>= 1;
    }
    return res;
}

string Init() {
    inv[1] = 1;
    for (int i = 2; i <= LIM; ++i) {
        inv[i] = 1ll * (P - P / i) * inv[P % i] % P;
    }
    return "Success";
}

string status = Init();

typedef vector<int> poly;

void simpl(poly &x) {
    while (!x.empty() && !x.back()) {
        x.pop_back();
    }
}

poly NTT(poly f, int type = 0) {
    int n = f.size();
    assert(n && !(n & (n - 1)));
    poly tr(n);
    for (int i = 1; i < n; ++i) {
        tr[i] = (tr[i >> 1] >> 1) | ((i & 1) ? n >> 1 : 0);
        if (i < tr[i]) {
            swap(f[i], f[tr[i]]);
        }
    }
    for (int len = 2; len <= n; len <<= 1) {
        int p = len >> 1, buf = ksm((type ? iG : G), (P - 1) / len);
        for (int i = 0; i < n; i += len) {
            int now = 1;
            for (int j = i; j < i + p; ++j) {
                int tmp = 1ll * now * f[j + p] % P;
                ((f[j + p] = f[j] - tmp) < 0) && (f[j + p] += P);
                ((f[j] += tmp) >= P) && (f[j] -= P);
                now = 1ll * now * buf % P;
            }
        }
    }
    if (type) {
        int invN = ksm(n);
        for (auto &v : f) {
            v = 1ll * v * invN % P;
        }
    }
    return f;
}

poly operator * (poly x, poly y) {
    if (x.empty() || y.empty()) {
        return {};
    }
    simpl(x), simpl(y);
    int len = x.size() + y.size() - 1, tLen = 1;
    while (tLen < len) {
        tLen <<= 1;
    }
    x.resize(tLen), y.resize(tLen);
    x = NTT(x), y = NTT(y);
    for (int i = 0; i < tLen; ++i) {
        x[i] = 1ll * x[i] * y[i] % P;
    }
    x = NTT(x, 1);
    simpl(x);
    return x;
}

int f[N], a[N];

void solve(int l, int r) {
    if (l == r) {
        f[l] = (f[l] + 1ll * (l - 1) * f[l - 1]) % P;
        return;
    }
    int mid = (l + r) >> 1;
    solve(l, mid);
    vector<int> F, G;
    for (int i = l; i <= mid; ++i) F.push_back(1ll * f[i] * (i - 1) % P);
    for (int i = 0; i <= mid && i <= r - l; ++i) G.push_back(i < 2 ? 0 : f[i]);
    F = F * G;
    for (int i = mid + 1; i <= r && i - l < (int)F.size(); ++i) f[i] = (f[i] + F[i - l]) % P;
    F.clear(), G.clear();
    for (int i = l; i <= mid; ++i) F.push_back(f[i]);
    for (int i = 0; i < l && i <= r - l; ++i) G.push_back(i < 2 ? 0 : 1ll * f[i] * (i - 1) % P);
    F = F * G;
    for (int i = mid + 1; i <= r && i - l < (int)F.size(); ++i) f[i] = (f[i] + F[i - l]) % P;
    solve(mid + 1, r);
}

signed main() {
    int T, n; scanf("%d%d", &T, &n);
    f[0] = 1, f[1] = 2;
    if (n >= 2) solve(2, n);
    while (T--) {
        for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
        vector< pair<int, int> > o;
        int res = 1;
        for (int i = 1; i <= n; ++i) {
            int cnt = 0;
            while (!o.empty() && o.back().first >= i - a[i] + 1) {
                o.pop_back(), ++cnt;
            }
            if (!o.empty() && o.back().second >= i - a[i] + 1) {
                res = 0;
                break;
            }
            res = 1ll * res * f[cnt] % P;
            o.push_back({i - a[i] + 1, i});
        }
        if (o.size() != 1) res = 0;
        printf("%d\n", res);
    }
    return 0;
}