#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 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];
    static bool spec[MAXN];
    fill(pt + 1, pt + n + 1, vector<int>());
    memset(suma, 0, (n + 1) << 2);
    memset(spec, 0, n + 1);

    for (int i = 1; i <= n; ++i) {
        pt[c[i]].push_back(i);
        suma[c[i]] += a[i];
        spec[c[i]] |= fob[i] != -1;
    }

    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] && !spec[k]) {
            bagC.insert(suma[k]);

            for (int u : pt[k])
                bagD.insert(a[u]);
        }

    static int dp[MAXM][MAXM];

    for (int i = 0; i <= C0; ++i)
        for (int j = 0; j <= D0; ++j)
            dp[i][j] = 0;

    dp[0][0] = 1;

    int sum = 0;

    for (int k = 1; k <= n; ++k)
        if (suma[k] && spec[k]) {
            vector<pii> prob[2];

            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 && ((fob[u] >> 1) & 1) == t)
                        must[!(fob[u] & 1)] += a[u];
                    else
                        curbag.insert(a[u]);
                }

                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;

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

            int mnC = max(0, sum - C1);
            int mnD = max(0, sum - D1);

            for (int i = min(sum, C0); i >= mnC; --i)
                for (int j = min(sum, D0); j >= mnD; --j)
                    if (dp[i][j]) {
                        ll cur = dp[i][j];

                        if (i + suma[k] <= C0) {
                            int *nxtdp = dp[i + suma[k]];

                            for (pii it : prob[0])
                                if (j + it.second <= D0)
                                    add_mod(nxtdp[j + it.first], cur * it.second % mod);
                        }

                        {
                            int *nxtdp = dp[i];

                            for (pii it : prob[1])
                                if (it.first > 0 && j + it.second <= D0)
                                    add_mod(nxtdp[j + it.first], cur * it.second % mod);

                            if (prob[1].size() && prob[1][0].second == 0)
                                nxtdp[j] = (ll)dp[i][j] * prob[1][0].first % mod;
                            else
                                nxtdp[j] = 0;
                        }
                    }

            sum += suma[k];
        }

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

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

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

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

        if (l > r)
            return 0;

        return l == 0 ? sumC[r] : (sumC[r] - sumC[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 ? sumD[r] : (sumD[r] - sumD[l - 1] + mod) % mod;
    };

    int ans = 0;

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

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

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

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

int main(void) {
    freopen("10.in", "r", stdin);

    int T;
    scanf("%d", &T);

    while (T--)
        solve();

    return 0;
}