#include <bits/stdc++.h>
#define rep(i,j,k) for(int i=(j);i<=(k);i++)
#define per(i,j,k) for(int i=(j);i>=(k);i--)
#define uint unsigned int
#define ll long long
#define ull unsigned long long
#define db double
#define ldb long double
#define pii pair<int,int>
#define pll pair<ll,ll>
#define mkp make_pair
#define eb emplace_back
#define SZ(S) (int)S.size()
#define mod 998244353
//#define mod 1000000007
#define inf 0x3f3f3f3f
#define linf 0x3f3f3f3f3f3f3f3f
using namespace std;

template <class T>
void chkmax(T &x,T y){
    if(x < y) x = y;
}

template <class T>
void chkmin(T &x,T y){
    if(x > y) x = y;
}

inline int popcnt(int x){
    return __builtin_popcount(x);
}

inline int ctz(int x){
    return __builtin_ctz(x);
}

template <int P>
class mod_int
{
    using Z = mod_int;

private:
    static int mo(int x) { return x < 0 ? x + P : x; }

public:
    int x;
    int val() const { return x; }
    mod_int() : x(0) {}
    template <class T>
    mod_int(const T &x_) : x(x_ >= 0 && x_ < P ? static_cast<int>(x_) : mo(static_cast<int>(x_ % P))) {}
    bool operator==(const Z &rhs) const { return x == rhs.x; }
    bool operator!=(const Z &rhs) const { return x != rhs.x; }
    Z operator-() const { return Z(x ? P - x : 0); }
    Z pow(long long k) const
    {
        Z res = 1, t = *this;
        while (k)
        {
            if (k & 1)
                res *= t;
            if (k >>= 1)
                t *= t;
        }
        return res;
    }
    Z &operator++()
    {
        x < P - 1 ? ++x : x = 0;
        return *this;
    }
    Z &operator--()
    {
        x ? --x : x = P - 1;
        return *this;
    }
    Z operator++(int)
    {
        Z ret = x;
        x < P - 1 ? ++x : x = 0;
        return ret;
    }
    Z operator--(int)
    {
        Z ret = x;
        x ? --x : x = P - 1;
        return ret;
    }
    Z inv() const { return pow(P - 2); }
    Z &operator+=(const Z &rhs)
    {
        (x += rhs.x) >= P && (x -= P);
        return *this;
    }
    Z &operator-=(const Z &rhs)
    {
        (x -= rhs.x) < 0 && (x += P);
        return *this;
    }
    Z operator-()
    {
        return -x;
    }
    Z &operator*=(const Z &rhs)
    {
        x = 1ULL * x * rhs.x % P;
        return *this;
    }
    Z &operator/=(const Z &rhs) { return *this *= rhs.inv(); }
#define setO(T, o)                                  \
    friend T operator o(const Z &lhs, const Z &rhs) \
    {                                               \
        Z res = lhs;                                \
        return res o## = rhs;                       \
    }
    setO(Z, +) setO(Z, -) setO(Z, *) setO(Z, /)
#undef setO
    
    friend istream& operator>>(istream& is, mod_int& x)
    {
        long long tmp;
        is >> tmp;
        x = tmp;
        return is;
    }
    friend ostream& operator<<(ostream& os, const mod_int& x)
    {
        os << x.val();
        return os;
    }
};

using Z = mod_int<mod>;
Z power(Z p,ll k){
    Z ans = 1;
    while(k){
        if(k % 2 == 1) ans *= p;
        p *= p;
        k /= 2;
    }
    return ans;
}
int n,hn,m,q,type;
Z val[15][525],tmp[525];
Z sum[15][525],P[525];

int msk[52105],_m[52105],_k[52105];
Z result[52105],vval[525];

Z ps0[525][1 << 8],ps1[525][1 << 8],psum[1 << 15],_tmp[15];
void solve(Z p){
    P[0] = 1;
    rep(i,1,m) P[i] = P[i - 1] * p; 
    rep(i,0,n - 1){
        per(j,m,0) sum[i][j] = sum[i][j + 1] + val[i][j] * P[j];
    }
    rep(i,0,m){
        rep(j,0,n - 1) _tmp[j] = sum[j][i];

        if(!i){
            psum[0] = 1;
            rep(S,1,(1 << n) - 1){
                int u = ctz(S);
                psum[S] = psum[S - (1 << u)] * _tmp[u];
            }
            continue;
        }
        ps0[i][0] = ps1[i][0] = 1;
        rep(S,1,(1 << hn) - 1){
            int u = ctz(S);
            ps0[i][S] = ps0[i][S - (1 << u)] * _tmp[u];
        }
        rep(S,1,(1 << (n - hn)) - 1){
            int u = ctz(S);
            ps1[i][S] = ps1[i][S - (1 << u)] * _tmp[u + hn];
        }
    }

    rep(i,1,q) result[i] += vval[_m[i]] * ps0[_k[i]][msk[i] & ((1 << hn) - 1)] * ps1[_k[i]][msk[i] >> hn] * psum[(1 << n) - 1 - msk[i]];
}
char str[25];

Z f[8005],g[8005];
void add(int p){
    per(i,n * m,0){
        g[i + 1] += g[i];
        g[i] = -p * g[i];
    }
}

int main(){
//    freopen("test.in","r",stdin);
    scanf("%d%d%d",&n,&q,&type);
    hn = n / 2;
    m = 250;
    rep(i,0,n - 1){
        int p,w,lim;
        scanf("%d",&p);
        val[i][0] = 1;
        rep(j,1,p){
            scanf("%d%d",&w,&lim);
            rep(k,0,m){
                tmp[k] = val[i][k];
                if(k >= w) tmp[k] += tmp[k - w];
            }
            rep(k,0,m){
                val[i][k] = tmp[k];
                if(k >= (lim + 1) * w) val[i][k] -= tmp[k - (lim + 1) * w];
            }
        }
    }
/*    rep(i,0,n - 1){
        rep(k,0,m) printf("%d ",val[i][k].val());
        printf("\n");
    }*/
    rep(i,1,q){
        scanf("%s",str);
        rep(j,0,n - 1) if(str[j] == '1') msk[i] |= 1 << j;
        scanf("%d%d",&_m[i],&_k[i]);
    }

    g[0] = 1;
    rep(i,0,n * m) add(i);
    Z cur,prd;
    rep(i,0,n * m){
        cur = 0;
        per(j,n * m + 1,1){
            f[j - 1] = g[j] + cur;
            cur = i * f[j - 1];
        }
//        rep(j,0,n * m) printf("%d ",f[j].val());
//        printf("\n");
        prd = 1;
        rep(j,0,n * m) if(i != j) prd *= i - j;
        prd = 1 / prd;
        rep(j,0,m){
            vval[j] = f[j] * prd;
            if(j) vval[j] += vval[j - 1]; 
        }
        solve(i);
    }
    rep(i,1,q) printf("%d\n",result[i].val());
	return 0;
}