#include <bits/stdc++.h>
#define PII pair<int, int>
using namespace std;
const int N = 1e5 + 3;
const int W = (N * 3);
const int M = 3e5 + 3;
const int mod = 998244353;
const int pr = 3;
const int ig = 332748118;
const int inv2 = 499122177;

inline int read() {
    char ch = getchar(); int x = 0, f = 1;
    while (!isdigit(ch)) {if (ch == '-') {f = -1;} ch = getchar();}
    while (isdigit(ch)) {x = (x << 3) + (x << 1) + ch - 48; ch = getchar();}
    return x * f;
}
int fac[W], inv[W];
inline int add(int x, int y) {x += y; return x >= mod ? x - mod : x;}
inline int del(int x, int y) {x -= y; return x < 0 ? x + mod : x;}
inline void Add(int &x, int y) {x = add(x, y);}
inline void Del(int &x, int y) {x = del(x, y);}
inline int qpow(int x, int y) {
    int res = 1;
    while (y) {
        if (y & 1) res = 1ll * res * x % mod;
        x = 1ll * x * x % mod;
        y >>= 1;
    }
    return res;
}
inline int C(int x, int y) {return (x < 0 || y < 0 || x < y) ? 0 : 1ll * fac[x] * inv[y] % mod * inv[x - y] % mod;}

struct Poly {
    int len, INV, oo;
    vector<int> f, g;

    void NTT(vector<int> &F) {
        int x, y, pw, g;
        for (int j = (len >> 1); j; j >>= 1) {
            g = qpow(pr, (mod - 1) / (j << 1));
            for (int i = 0; i < len; i += (j << 1)) {
                pw = 1;
                for (int k = 0; k < j; ++k, pw = 1ll * pw * g % mod) {
                    x = F[i + k]; y = F[i + j + k];
                    F[i + k] = add(x, y);
                    F[i + j + k] = 1ll * pw * del(x, y) % mod;
                }
            }
        }
    }

    void INTT(vector<int> &F) {
        int x, y, pw, g;
        for (int j = 1; j < len; j <<= 1) {
            g = qpow(ig, (mod - 1) / (j << 1));
            for (int i = 0; i < len; i += (j << 1)) {
                pw = 1;
                for (int k = 0; k < j; ++k, pw = 1ll * pw * g % mod) {
                    x = F[i + k]; y = 1ll * pw * F[i + j + k] % mod;
                    F[i + k] = add(x, y);
                    F[i + j + k] = del(x, y);
                }
            }
        }
        for (int i = 0; i < len; ++i) F[i] = 1ll * F[i] * INV % mod;
    }

    void mul() {
        NTT(f); NTT(g);
        for (int i = 0; i < len; ++i) f[i] = 1ll * f[i] * g[i] % mod;
        INTT(f);
    }
    
    void init(int n) {
        len = 1; oo = n;
        while (len <= n + n) len <<= 1;
        INV = qpow(len, mod - 2);
        f.clear(); g.clear();
        f.resize(len + 5); g.resize(len + 5);
    }

    void get() {for (int i = oo + 1; i < f.size(); ++i) f[i] = g[i] = 0;}
    void clear() {for (int i = 0; i < f.size(); ++i) f[i] = g[i] = 0;}
}t;

int T, c, p, q, L, cnt, pos[10][10], pw[N][10], S[10][10];
PII id[10];

inline int calc(int x, int y, int k) {return 1ll * pw[x][id[k].first] * pw[y][id[k].second] % mod;}

namespace subtask1 {
    const int N1 = 1005;

    int f[N1][N1], g[N1][N1][10];
    
    bool check() {return L <= 1000;}

    void solve() {
        f[0][0] = 1;
        for (int i = 0; i < cnt; ++i) g[0][0][i] = calc(0, 0, i);
        for (int i = 0; i <= L; ++i)
            for (int j = 0; j <= L; ++j) {
                if (i == 0 && j == 0) continue;
                if (i) Add(f[i][j], f[i - 1][j]);
                if (j) Add(f[i][j], f[i][j - 1]);
                for (int k = 0; k < cnt; ++k) {
                    if (i) Add(g[i][j][k], g[i - 1][j][k]);
                    if (j) Add(g[i][j][k], g[i][j - 1][k]);
                    if (j <= i) Add(g[i][j][k], 1ll * f[i][j] * calc(i, j, k) % mod);
                }
            }
        int n, m, ans;
        while (T--) {
            n = read(); m = read(); ans = 0;
            for (int i = 0; i < cnt; ++i) Add(ans, 1ll * g[n][m][i] * read() % mod);
            printf("%d\n", ans);
        }
    }
}

namespace subtask2 {
    int f[N], g[N], n, m, v, ans;

    bool check() {return T == 1 && p == 0 && q == 0;}

    void solve() {
        n = read(); m = read(); v = read();
        if (n == m) {
            g[n] = qpow(4, n);
			f[n] = 1ll * del(1ll * (n + m + 1) * C(n + m, n) % mod, g[n]) * inv2 % mod;
            printf("%lld\n", 1ll * add(f[n], g[n]) * v % mod);
        }else if (n < m) {
			g[0] = 1;
			for (int i = 1; i <= n; ++i) g[i] = 4ll * g[i - 1] % mod;
			for (int i = 0; i <= n; ++i) {
				f[i] = 1ll * del(1ll * (i + i + 1) * C(i + i, i) % mod, g[i]) * inv2 % mod;
				Add(ans, 1ll * add(f[i], g[i]) * del(C(n - i + m - i - 1, n - i), C(n - i + m - i - 1, n - i - 1)) % mod);
			}
			ans = 1ll * ans * v % mod;
			printf("%d\n", ans);
        }else {
			g[0] = 1; ans = 1ll * (n + m + 1) * C(n + m, n) % mod;
			for (int i = 1; i <= m; ++i) g[i] = 4ll * g[i - 1] % mod;
			for (int i = 0; i <= m; ++i) {
				f[i] = 1ll * del(1ll * (i + i + 1) * C(i + i, i) % mod, g[i]) * inv2 % mod;
				Del(ans, 1ll * f[i] * del(C(n - i - 1 + m - i, m - i), C(n - i - 1 + m - i, n - i)) % mod);
			}
			ans = 1ll * ans * v % mod;
			printf("%d\n", ans);
		}
    }
}

namespace subtask3 {
    bool check() {return p == 0 && q == 0;}

    void solve() {
        t.init(L + 5);
        if (c == 0) {
            for (int i = 0, g = 1; i <= L; ++i, g = 4ll * g % mod)
                t.f[i] = 1ll * add(1ll * (i + i + 1) * C(i + i, i) % mod, g) * inv2 % mod;
            int n, m, v;
            while (T--) {
                n = read(); m = read(); v = read();
                printf("%lld\n", 1ll * t.f[n] * v % mod);
            }
        }else if (c > 0) {
            for (int i = 0, g = 1; i <= L; ++i, g = 4ll * g % mod)
                t.f[i] = 1ll * add(1ll * (i + i + 1) * C(i + i, i) % mod, g) * inv2 % mod;
            for (int i = 0; i <= L; ++i) t.g[i] = del(C(i + i + c - 1, i), C(i + i + c - 1, i - 1));
            t.mul();
            int n, m, v;
            while (T--) {
                n = read(); m = read(); v = read();
                printf("%lld\n", 1ll * t.f[n] * v % mod);
            }
        }else {
            c = -c;
            for (int i = 0, g = 1; i <= L; ++i, g = 4ll * g % mod)
                t.f[i] = 1ll * del(1ll * (i + i + 1) * C(i + i, i) % mod, g) * inv2 % mod;
            for (int i = 0; i <= L; ++i) t.g[i] = del(C(i + i + c - 1, i), C(i + i + c - 1, i - 1));
            t.mul();
            int n, m, v;
            while (T--) {
                n = read(); m = read(); v = read();
                printf("%lld\n", 1ll * del(1ll * (n + m + 1) * C(n + m, n) % mod, t.f[m]) * v % mod);
            }
        }
    }
}

namespace subtask4 {
    int ans, a[10], val[N << 1], pre[N << 1], f[N];

    bool check() {return T == 1;}

    int work(int n, int m, int k, int lim) {
        if (n < 0 || m < 0) return 0;
        for (int i = 0; i <= n + m; ++i) {
            val[i] = 1;
            for (int j = 1; j <= k; ++j) val[i] = 1ll * val[i] * (i + j) % mod;
            if (i == 0) pre[i] = val[i];
            else pre[i] = add(pre[i - 1], val[i]);
        }
        int res;
        if (n == m) {
            res = 1ll * pre[n + m] * C(n + m, n) % mod;
            for (int i = 0; i <= n; ++i) Add(res, 1ll * C(i + i, i) * C(n - i + m - i, n - i) % mod * val[i + i] % mod);
            res = 1ll * res * inv2 % mod;
        }else if (n < m) {
            t.init(n);
            for (int i = 0; i <= n; ++i) {
                t.f[i] = 1ll * C(i + i, i) * val[i + i] % mod;
                t.g[i] = C(i + i, i);
            }
            t.mul(); res = 0;
            for (int i = 0, tmp; i <= n; ++i) {
                tmp = 1ll * add(1ll * pre[i + i] * C(i + i, i) % mod, t.f[i]) * inv2 % mod;
                Add(res, 1ll * tmp * del(C(n - i + m - i - 1, n - i), C(n - i + m - i - 1, n - i - 1)) % mod);
            }
        }else {
            t.init(m);
            for (int i = 0; i <= m; ++i) {
                t.f[i] = 1ll * C(i + i, i) * val[i + i] % mod;
                t.g[i] = C(i + i, i);
            }
            t.mul(); res = 1ll * pre[n + m] * C(n + m, n) % mod;
            for (int i = 0, tmp; i <= m; ++i) {
                tmp = 1ll * del(1ll * pre[i + i] * C(i + i, i) % mod, t.f[i]) * inv2 % mod;
                Del(res, 1ll * tmp * del(C(n - i - 1 + m - i, m - i), C(n - i - 1 + m - i, m - i - 1)) % mod);
            }
        }
        for (int o = 0; o < lim; ++o)
            for (int i = o; i <= n && i - o <= m; ++i)
                Del(res, 1ll * C(i + i - o, i) * C(n - i + m - i + o, n - i) % mod * val[i + i - o] % mod);
        for (int o = lim; o < 0; ++o)
            for (int i = 0; i <= n && i - o <= m; ++i)
                Add(res, 1ll * C(i + i - o, i) * C(n - i + m - i + o, n - i) % mod * val[i + i - o] % mod);
        return res;
    }

    void solve() {
        int n, m;
        n = read(); m = read();
        for (int i = 0; i < cnt; ++i) a[i] = read();
        for (int s = 0; s <= p && s <= n; ++s) {
            for (int t = 0, res; t <= q && t <= m; ++t) {
                res = 0;
                for (int u = s; u <= p; ++u)
                    for (int v = t; v <= q; ++v)
                        Add(res, 1ll * a[pos[u][v]] * S[u][s] % mod * S[v][t] % mod);
                Add(ans, 1ll * res * work(n - s, m - t, s + t, t - s) % mod);
            }
        }
        printf("%d\n", ans);
    }
}

namespace subtask5 {
    int mem[10][N], val[N << 1], pre[N << 1], ans, a[10];

    void work(int d, int k, int lim, int op) {
        for (int i = 0; i <= L + L; ++i) {
            val[i] = 1;
            for (int j = 1; j <= k; ++j) val[i] = 1ll * val[i] * (i + j) % mod;
            if (i == 0) pre[i] = val[i];
            else pre[i] = add(pre[i - 1], val[i]);
        }
        for (int i = 0; i <= L; ++i) {
            t.f[i] = 1ll * C(i + i, i) * val[i + i] % mod;
            t.g[i] = C(i + i, i);
        }
        t.mul(); t.get();
        if (d == 0) {
            for (int i = 0; i <= L; ++i) mem[op][i] = 1ll * add(1ll * pre[i + i] * C(i + i, i) % mod, t.f[i]) * inv2 % mod;
            t.clear();
            for (int o = 0; o < lim; ++o) {
                for (int i = o; i <= L; ++i) {
                    t.f[i] = 1ll * C(i + i - o, i) * val[i + i - o] % mod;
                    t.g[L - i] = C(L - i + L - i + d + o, L - i);
                }
                t.mul();
                for (int i = 0; i <= L; ++i) Del(mem[op][i], t.f[i]);
                t.clear();
            }
            for (int o = lim; o < 0; ++o) {
                for (int i = 0; i <= L; ++i) {
                    t.f[i] = 1ll * C(i + i - o, i) * val[i + i - o] % mod;
                    t.g[L - i] = C(L - i + L - i + d + o, L - i);
                }
                t.mul();
                for (int i = 0; i <= L; ++i) Add(mem[op][i], t.f[i]);
                t.clear();
            }
        }else if (d > 0) {
            for (int i = 0; i <= L; ++i) t.f[i] = 1ll * add(1ll * pre[i + i] * C(i + i, i) % mod, t.f[i]) * inv2 % mod;
            for (int i = 0; i <= L; ++i) t.g[i] = del(C(i + i + d - 1, i), C(i + i + d - 1, i - 1));
            t.mul();
            for (int i = 0; i <= L; ++i) mem[op][i] = t.f[i];
            t.clear();
            for (int o = 0; o < lim; ++o) {
                for (int i = o; i <= L; ++i) {
                    t.f[i] = 1ll * C(i + i - o, i) * val[i + i - o] % mod;
                    t.g[L - i] = C(L - i + L - i + d + o, L - i);
                }
                t.mul();
                for (int i = 0; i <= L; ++i) Del(mem[op][i], t.f[i]);
                t.clear();
            }
            for (int o = lim; o < 0; ++o) {
                for (int i = 0; i <= L; ++i) {
                    t.f[i] = 1ll * C(i + i - o, i) * val[i + i - o] % mod;
                    t.g[L - i] = C(L - i + L - i + d + o, L - i);
                }
                t.mul();
                for (int i = 0; i <= L; ++i) Add(mem[op][i], t.f[i]);
                t.clear();
            }
        }else {
            d = -d;
            for (int i = 0; i <= L; ++i) t.f[i] = 1ll * del(1ll * pre[i + i] * C(i + i, i) % mod, t.f[i]) * inv2 % mod;
            for (int i = 0; i <= L; ++i) t.g[i] = del(C(i + d - 1 + i, i), C(i + d - 1 + i, i - 1));
            t.mul();
            for (int i = 0; i <= L; ++i) mem[op][i] = t.f[i];
            t.clear(); lim = -lim;
            for (int o = 1; o <= lim; ++o) {
                for (int i = o; i <= L; ++i) {
                    t.f[i] = 1ll * C(i + i - o, i) * val[i + i - o] % mod;
                    t.g[L - i] = C(L - i + L - i + d + o, L - i);
                }
                t.mul();
                for (int i = 0; i <= L; ++i) Del(mem[op][i], t.f[i]);
                t.clear();
            }
            for (int o = lim + 1; o <= 0; ++o) {
                for (int i = 0; i <= L; ++i) {
                    t.f[i] = 1ll * C(i + i - o, i) * val[i + i - o] % mod;
                    t.g[L - i] = C(L - i + L - i + d + o, L - i);
                }
                t.mul();
                for (int i = 0; i <= L; ++i) Add(mem[op][i], t.f[i]);
                t.clear();
            }
            for (int i = 0; i <= L; ++i) mem[op][i] = del(1ll * pre[i + i + d] * C(i + i + d, i) % mod, mem[op][i]);
        }
    }
    
    void solve() {
        t.init(L);
        for (int i = 0, s, t; i < cnt; ++i) {
            s = id[i].first; t = id[i].second;
            work(c - t + s, s + t, t - s, i);
        }
        int n, m;
        while (T--) {
            n = read(); m = read();
            for (int i = 0; i < cnt; ++i) a[i] = read();
            ans = 0;
            for (int s = 0; s <= p && s <= n; ++s) {
                for (int t = 0; t <= q && t <= m; ++t) {
                    int res = 0;
                    for (int u = s; u <= p; ++u)
                        for (int v = t; v <= q; ++v)
                            Add(res, 1ll * S[u][s] * S[v][t] % mod * a[pos[u][v]] % mod);
                    if (c - t + s >= 0) Add(ans, 1ll * res * mem[pos[s][t]][n - s] % mod);
                    else Add(ans, 1ll * res * mem[pos[s][t]][m - t] % mod);
                }
            }
            printf("%d\n", ans);
        }
    }
}

int main() {
    fac[0] = 1;
    for (int i = 1; i <= M; ++i) fac[i] = 1ll * fac[i - 1] * i % mod;
    inv[M] = qpow(fac[M], mod - 2);
    for (int i = M; i >= 1; --i) inv[i - 1] = 1ll * inv[i] * i % mod;
    S[0][0] = 1;
    for (int i = 1; i < 10; ++i)
        for (int j = 1; j <= i; ++j)
            S[i][j] = add(S[i - 1][j - 1], 1ll * S[i - 1][j] * j % mod);
    T = read(); c = read(); p = read(); q = read(); L = read(); L = max(L, L + c);
    for (int i = 0; i <= p; ++i)
        for (int j = 0; j <= q; ++j)
            id[pos[i][j] = cnt++] = make_pair(i, j);
    for (int i = 0; i <= L; ++i) {
        pw[i][0] = 1;
        for (int j = 1; j <= max(p, q); ++j) pw[i][j] = 1ll * pw[i][j - 1] * i % mod;
    }
    if (subtask1 :: check()) subtask1 :: solve();
    else if (subtask2 :: check()) subtask2 :: solve();
    else if (subtask3 :: check()) subtask3 :: solve();
    else if (subtask4 :: check()) subtask4 :: solve();
    else subtask5 :: solve();
    return 0;
}