#include <bits/stdc++.h>

using namespace std;

using ll = long long;

const int mod = 998244353;
int norm(int x) { return x >= mod ? x - mod : x; }
int reduce(int x) { return x < 0 ? x + mod : x; }
int neg(int x) { return x ? mod - x : 0; }
void add(int &x, int y) { if ((x += y - mod) < 0) x += mod; }
void sub(int &x, int y) { if ((x -= y) < 0) x += mod; }
void fam(int &x, int y, int z) { x = (x + (ll)y * z) % mod; }
int mpow(int a, int b) {
  int ret = 1;
  for (; b; b >>= 1) {
    if (b & 1) ret = (ll)ret * a % mod;
    a = (ll)a * a % mod;
  }
  return ret;
}

pair<vector<int>, vector<int>> berlekampMassey(int n, const vector<int> &base) {
  vector<int> u(n * 2 + 1), v(n * 2), x, y(1, 1);
  u[n * 2] = 1;
  for (int i = 0; i < v.size(); ++i) v[i] = base[i];
  while (1) {
    while (!v.empty() && !v.back()) v.pop_back();
    if (v.size() - 1 < n && y.size() - 1 <= n) break;
    x.resize(max(x.size(), u.size() - v.size() + y.size()));
    int t = neg(mpow(v.back(), mod - 2));
    for (int i = u.size() - v.size(); i >= 0; --i) {
      int c = (ll)t * u[i + v.size() - 1] % mod;
      for (int j = 0; j < y.size(); ++j) fam(x[i + j], c, y[j]);
      for (int j = 0; j < v.size(); ++j) fam(u[i + j], c, v[j]);
    }
    swap(u, v), swap(x, y);
  }
  int inv = mpow(y[0], mod - 2);
  for (int i = 0; i < y.size(); ++i) y[i] = (ll)y[i] * inv % mod;
  for (int i = 0; i < v.size(); ++i) v[i] = (ll)v[i] * inv % mod;
  return make_pair(v, y);
}

vector<int> operator*(vector<int> a, vector<int> b) {
  vector<int> ret(a.size() + b.size() - 1);
  for (int i = 0; i < a.size(); ++i)
    for (int j = 0; j < b.size(); ++j)
      fam(ret[i + j], a[i], b[j]);
  return ret;
}
vector<int> polyMod(vector<int> u, vector<int> v) {
  int n = u.size() - 1, m = v.size() - 1;
  for (; n && !u[n]; --n) u.pop_back(); for (; m && !v[m]; --m) v.pop_back();
  if (!v[m]) return {};
  int inv = mpow(v[m], mod - 2);
  for (int i = 0; i <= m; ++i) v[i] = (ll)v[i] * inv % mod;
  while (n >= m) {
    int t = u[n];
    for (int i = 0; i <= m; ++i) u[n - m + i] = (u[n - m + i] + (ll)(mod - t) * v[i]) % mod;
    for (; n && !u[n]; --n) u.pop_back();
  }
  return u;
}

const int LG = 64;
const int K = 8;
const int B = 1e3;
const int W = 8;

int T, m, k;
ll n;
int inv[K + 2];
int f[B + 5][K + 1][K + 1][K + 1];
vector<int> base(B + 1), q;
vector<int> pw[LG / W + 1][(1 << W) + 1];
int query(ll n) {
  vector<int> res(1, 1);
  for (int p = 0; n; n >>= W, ++p) res = polyMod(res * pw[p][n & ((1 << W) - 1)], q);
  int ret = 0;
  for (int i = 0; i < res.size(); ++i) fam(ret, res[i], base[i]);
  return ret;
}

int main() {
  scanf("%d%d%d", &T, &m, &k);
  inv[1] = 1;
  for (int i = 2; i <= k + 1; ++i) inv[i] = (ll)(mod - mod / i) * inv[mod % i] % mod;
  for (int i = 1; i <= B; ++i)
    for (int a = 0; a <= k; ++a)
      for (int b = 0; a + b <= k; ++b)
        for (int c = 0; a + b + c <= k; ++c) {
          f[i][a][b][c] = (f[i][a][b][c] + (ll)(f[i - 1][a][b][c] + 1) * inv[a + b + c + 1]) % mod;
          if (a) f[i][a][b][c] = (f[i][a][b][c] + (ll)f[i - 1][a - 1][b][c] * a % mod * inv[a + b + c + 1]) % mod;
          if (b) f[i][a][b][c] = (f[i][a][b][c] + (ll)f[i - 1][a + 1][b - 1 + (a + b + c < k && m == 2)][c + (a + b + c < k && m == 3)] * b % mod * inv[a + b + c + 1]) % mod;
          if (c) f[i][a][b][c] = (f[i][a][b][c] + (ll)f[i - 1][a][b + 1][c - 1 + (a + b + c < k)] * c % mod * inv[a + b + c + 1]) % mod;
        }
  for (int i = 0; i <= B; ++i) base[i] = f[i][m == 1][m == 2][m == 3];
  q = berlekampMassey(base.size() >> 1, base).second, reverse(q.begin(), q.end());
  for (int p = 0; p * W <= LG; ++p) {
    auto w = p ? pw[p - 1][1 << W] : vector<int>({0, 1});
    pw[p][0] = {1};
    for (int i = 1; i <= (1 << W); ++i) pw[p][i] = polyMod(pw[p][i - 1] * w, q);
  }
  for (; T; --T) scanf("%lld", &n), printf("%d\n", query(n));
}