#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
const int MAXN = 1e3 + 5;
const int MAXM = 2.5e3 + 5;
const int MAXS = 3e2 + 5;
const int inf = 0x3f3f3f3f;
const int mod = 998244353;

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

    if (a >= mod)
        a -= mod;
}

struct Bagdp {
    int dp[MAXM], C0, C1, sum;
    void init(int _C0, int _C1) {
        C0 = _C0;
        C1 = _C1;
        memset(dp, 0, (C0 + 1) << 2);
        dp[0] = 1;
        sum = 0;
    }
    void insert(int x) {
        int mni = max(0, sum - C1);
        int mxi = min(sum, C0 - x);

        for (int i = mxi; i >= mni; --i)
            add_mod(dp[i + x], dp[i]);

        sum += x;

        for (int i = mni; i < sum - C1; ++i)
            dp[i] = 0;
    }
};

int c[MAXN], a[MAXN], fob[MAXN];

void solve(void) {
    int n, d;
    int C0, C1, D0, D1;
    scanf("%d%*d%d%d%d%d", &n, &C0, &C1, &D0, &D1);

    for (int i = 1; i <= n; ++i)
        scanf("%d%d", &c[i], &a[i]);

    memset(fob, -1, (n + 1) << 2);
    scanf("%d", &d);

    for (int i = 1; i <= d; ++i) {
        int x, y;
        scanf("%d%d", &x, &y);
        fob[x] = y;
    }

    static vector<int> pt[MAXN];
    static int suma[MAXN];
    fill(pt + 1, pt + n + 1, vector<int>());
    memset(suma, 0, (n + 1) << 2);

    for (int i = 1; i <= n; ++i) {
        suma[c[i]] += a[i];

        if (fob[i] != -1)
            pt[c[i]].push_back(i);
    }

    for (int i = 1; i <= n; ++i)
        if (suma[i] > max(C0, C1)) {
            printf("0\n");
            return;
        }

    if (accumulate(suma + 1, suma + n + 1, 0) > min(C0 + C1, D0 + D1)) {
        printf("0\n");
        return;
    }

    static Bagdp bagC, bagD;
    bagC.init(C0, C1);
    bagD.init(D0, D1);

    for (int k = 1; k <= n; ++k)
        if (suma[k] && !pt[k].size())
            bagC.insert(suma[k]);

    for (int i = 1; i <= n; ++i)
        if (fob[i] == -1)
            bagD.insert(a[i]);

    static int dp[2][MAXM][MAXS];
    memset(dp, 0, sizeof(dp));
    int now = 0;
    dp[now][0][0] = 1;

    int sumC = 0, sumD = 0;

    for (int k = 1; k <= n; ++k)
        if (pt[k].size()) {
            memset(dp[now ^ 1], 0, sizeof(dp[now ^ 1]));

            for (int t = 0; t <= 1; ++t) {
                if (suma[k] > (t == 0 ? C0 : C1))
                    continue;

                static Bagdp curbag;
                curbag.init(D0, D1);
                int must[2] = {0, 0};

                for (int u : pt[k]) {
                    if (((fob[u] >> 1) & 1) == t)
                        must[!(fob[u] & 1)] += a[u];
                    else
                        curbag.insert(a[u]);
                }

                vector<pii> may;

                for (int i = 0; i <= D0 && i <= curbag.sum; ++i)
                    if (i + must[0] <= D0 && curbag.sum - i + must[1] <= D1) {
                        if (!curbag.dp[i])
                            continue;

                        may.emplace_back(i + must[0], curbag.dp[i]);
                    }

                int mnC = max(0, sumC - C1), mxC = min(sumC, C0);
                int mnD = max(0, sumD - D1), mxD = min(sumD, D0);

                for (int i = mnC; i <= mxC; ++i) {
                    int ii = i + (t == 0 ? suma[k] : 0);

                    if (ii > C0)
                        break;

                    for (int j = mnD; j <= mxD; ++j)
                        if (dp[now][i][j])
                            for (pii it : may) {
                                if (j + it.first > D0)
                                    break;

                                add_mod(dp[now ^ 1][ii][j + it.first], (ll)dp[now][i][j] * it.second % mod);
                            }
                }
            }

            sumC += suma[k];

            for (int u : pt[k])
                sumD += a[u];

            now ^= 1;
        }

    static int dpC[MAXM], dpD[MAXM];
    memcpy(dpC, bagC.dp, (C0 + 1) << 2);
    memcpy(dpD, bagD.dp, (D0 + 1) << 2);

    for (int i = 1; i <= C0; ++i)
        add_mod(dpC[i], dpC[i - 1]);

    for (int i = 1; i <= D0; ++i)
        add_mod(dpD[i], dpD[i - 1]);

    auto getC = [&](int l, int r) {
        l = max(l, 0);
        r = min(r, C0);

        if (l > r)
            return 0;

        return l == 0 ? dpC[r] : (dpC[r] - dpC[l - 1] + mod) % mod;
    };
    auto getD = [&](int l, int r) {
        l = max(l, 0);
        r = min(r, D0);

        if (l > r)
            return 0;

        return l == 0 ? dpD[r] : (dpD[r] - dpD[l - 1] + mod) % mod;
    };

    int ans = 0;

    for (int i = 0; i <= C0 && i <= sumC; ++i)
        if (sumC - i <= C1)
            for (int j = 0; j <= D0 && j <= sumD; ++j)
                if (sumD - j <= D1) {
                    if (!dp[now][i][j])
                        continue;

                    int LC = sumC + bagC.sum - C1 - i, RC = C0 - i;
                    int LD = sumD + bagD.sum - D1 - j, RD = D0 - j;

                    add_mod(ans, (ll)dp[now][i][j] * getC(LC, RC) % mod * getD(LD, RD) % mod);
                }

    printf("%d\n", ans);
}

int main(void) {
    int T;
    scanf("%d", &T);

    while (T--)
        solve();

    return 0;
}