#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
const int mod = 998244353;
const ll inv2 = (mod + 1) / 2;

namespace FastIO {
const int SIZ1 = 1 << 23;
char buf1[SIZ1], *s1 = buf1, *t1 = buf1;
inline char gc(void) {
    return s1 == t1 && (t1 = buf1 + fread(buf1, 1, SIZ1, stdin)) == (s1 = buf1) ? EOF : *s1++;
}
template<typename T>
void read(T &res) {
    res = 0;
    char c = gc();

    while (c < '0' || c > '9')
        c = gc();

    while (c >= '0' && c <= '9')
        res = res * 10 + c - '0', c = gc();
}
} using FastIO::read;

inline void add_mod(int &a, int b) {
    a += b;

    if (a >= mod)
        a -= mod;
}
inline int mod_add(int a, int b) {
    return a + b >= mod ? a + b - mod : a + b;
}

inline ll pw(ll a, ll b) {
    ll res = 1;

    while (b) {
        if (b & 1)
            res = res * a % mod;

        a = a * a % mod;
        b >>= 1;
    }

    return res;
}

const int MX = 168;

struct Matrix {
    static int N;
    int a[MX][MX];
    Matrix(void) {
        memset(a, 0, sizeof(a));
    }
    int *operator [](int x) {
        return a[x];
    }
    const int *operator [](int x) const {
        return a[x];
    }
#define FOR(i) for(int i=0; i<N; i+=8)
#define fi fj(0)fj(1)fj(2)fj(3)fj(4)fj(5)fj(6)fj(7)
    Matrix operator * (const Matrix &b) const {
#define V(i,j,k) 1ll * a[ti+i][tk+k] * b[tk+k][tj+j]
#define fj(i) fk(i,0)fk(i,1)fk(i,2)fk(i,3)fk(i,4)fk(i,5)fk(i,6)fk(i,7)
#define fk(i,j) res[ti+i][tj+j]=(res[ti+i][tj+j]+V(i,j,0)+V(i,j,1)+V(i,j,2)+V(i,j,3)+V(i,j,4)+V(i,j,5)+V(i,j,6)+V(i,j,7))%mod;
        Matrix res;
        FOR(ti)FOR(tj)FOR(tk) {
            fi
        }
        return res;
#undef V
#undef fj
#undef fk
    }
    void aply(int b[]) const {
#define V(i,j) 1ll * a[ti+i][tj+j] * b[tj+j]
#define fj(i) res[ti+i]=(res[ti+i]+V(i,0)+V(i,1)+V(i,2)+V(i,3)+V(i,4)+V(i,5)+V(i,6)+V(i,7))%mod;
        int res[MX];
        memset(res, 0, sizeof(res));
        FOR(ti)FOR(tj) {
            fi
        }
        memcpy(b, res, (N + 1) << 2);
#undef V
#undef fj
    }
#undef FOR
#undef fi
};
int Matrix::N;

int main(void) {
    int T, m, d;
    read(T);
    read(m);
    read(d);

    if (m == 1) {
        while (T--) {
            ll n;
            read(n);
            printf("%d\n", mod_add(n - 1, pw(inv2, n)));
        }

        return 0;
    }

    static int id[9][9][9], pcnt = 0;
    static tuple<int, int, int> deco[MX];

    for (int i = 0; i <= d; ++i)
        for (int j = 0; i + j <= d; ++j)
            for (int k = 0; i + j + k <= d; ++k) {
                if (m == 2 && k)
                    continue;

                deco[pcnt] = tie(i, j, k);
                id[i][j][k] = pcnt++;
            }

    int beg = m == 2 ? id[0][1][0] : id[0][0][1];

    Matrix::N = pcnt + 1;

    Matrix a;

    for (int u = 0; u < pcnt; ++u) {
        int i, j, k;
        tie(i, j, k) = deco[u];
        ll iv = pw(i + j + k + 1, mod - 2);
        int flag2 = m == 2, flag3 = m == 3;

        if (i + j + k >= d)
            flag2 = flag3 = 0;;

        if (i)
            add_mod(a[ id[i - 1][j][k]][u], iv * i % mod);

        if (j)
            add_mod(a[ id[i + 1][j - 1 + flag2][k  + flag3]][u], iv * j % mod);

        if (k)
            add_mod(a[ id[i  ][j + 1 + flag2][k - 1 + flag3]][u], iv * k % mod);

        add_mod(a[u][u], iv);
        add_mod(a[pcnt][u], iv);
    }

    add_mod(a[pcnt][pcnt], 1);

    static const int lb = 60;
    static Matrix pwa[lb];
    pwa[0] = a;

    for (int i = 1; i < lb; ++i)
        pwa[i] = pwa[i - 1] * pwa[i - 1];

    while (T--) {
        ll n;
        read(n);

        static int res[MX];
        memset(res, 0, sizeof(res));
        res[beg] = 1;

        for (int i = 0; n; ++i, n >>= 1)
            if (n & 1)
                pwa[i].aply(res);

        printf("%d\n", res[pcnt]);
    }

    return 0;
}