#include <bits/stdc++.h>
using namespace std;
#define M 64
using ull = unsigned long long;
template<class T>void Rd(T &x){
    static char c;
    while(c=getchar(),!isdigit(c));
    for(x=0;isdigit(c);c=getchar())
        x=(x<<1)+(x<<3)+(c^48);
}
bool cnt[1<<16];
void Init(){
    for(int i=1;i<1<<16;i++)
        cnt[i] = cnt[i^(i&-i)]^1;
}
const ull BB = (1<<16)-1;
inline bool COUNT(const ull &x){
    return cnt[x&BB]^cnt[(x>>16)&BB]^cnt[(x>>32)&BB]^cnt[(x>>48)&BB];
}
struct Matrix{
    bitset<M>A[M];
    ull u[M],v[M];
    void get(){
        for(int i=0;i<M;i++)
            for(int j=0;j<M;j++){
                u[i] |= (ull)(A[i][j])<<j;
                v[j] |= (ull)(A[i][j])<<i;
            }
    }
    Matrix operator * (const Matrix &res)const{
        Matrix ret;
        for(int i=0;i<M;i++)
            for(int j=0;j<M;j++)
                ret.A[i][j]=COUNT(u[i]&res.v[j]);
        ret.get();
        return ret;
    }
    Matrix operator + (const Matrix &res)const{
        Matrix ret;
        for(int i=0;i<M;i++){
            ret.A[i]=A[i]^res.A[i];
            ret.u[i]=u[i]^res.u[i];
            ret.v[i]=v[i]^res.v[i];
        }
        return ret;
    }
    ull operator & (const ull &res)const{
        ull ret = 0;
        for(int i=0;i<M;i++)
            ret ^= ((ull)(COUNT(u[i]&res))<<i);
        return ret;
    }
    Matrix(){
        memset(u,0,sizeof(u));
        memset(v,0,sizeof(v));
        memset(A,0,sizeof(A));
    }
};
struct Node{
    Matrix k;
    ull b;
    Node(){}
    Node(Matrix aa,ull bb):k(aa),b(bb){}
    Node operator + (const Node &res)const{
        return Node(k*res.k,(k&res.b)^b);
    }
    ull Ask(ull x){
        return ((k&x)^b);
    } 
}Val[20005];
struct Seg{
    struct TNODE{
        int l,r;
        Node v;
    }tree[20005<<2];
    #define fa tree[p]
    #define lson tree[p<<1]
    #define rson tree[p<<1|1]
    int pos[20005];
    void Up(int p){
        fa.v = rson.v + lson.v;
    }
    void build(int l,int r,int p=1){
        fa.l=l,fa.r=r;
        if(l==r){
            pos[l]=p;
            fa.v=Val[l];
            return;
        }
        int mid=l+r>>1;
        build(l,mid,p<<1);
        build(mid+1,r,p<<1|1);
        Up(p);
    }
    void Update(int x){
        int p = pos[x];
        fa.v = Val[x];
        for(int i=p>>1;i;i>>=1)Up(i);
    }
    ull Query(int l,int r,ull x,int p=1){
        if(l==fa.l && r==fa.r)return fa.v.Ask(x);
        int mid=fa.l+fa.r>>1;
        if(r<=mid)return Query(l,r,x,p<<1);
        else if(l>mid)return Query(l,r,x,p<<1|1);
        else return Query(mid+1,r,Query(l,mid,x,p<<1),p<<1|1);
    }
    #undef fa
    #undef lson
    #undef rson
}T;
int m,s[20005];
ull A[20005],B;
int o[20005];
Matrix AND(ull p){
    Matrix ret;
    for(int i=0;i<64;i++)
        if((1ull<<i)&p){
            ret.A[i][i]=1;
            ret.u[i]|=1ull<<i;
            ret.v[i]|=1ull<<i;
        }
    return ret;
}
Matrix Shift(int s){
    Matrix ret;
    for(int i=0;i<64;i++){
        ret.A[i][(i-s+64)%64]=1;
        ret.u[i]|=1ull<<(i-s+64)%64;
        ret.v[(i-s+64)%64]|=1ull<<i;
    }
    return ret;
}
const ull BS = -1;
Node Trans(){
    Matrix k;
    ull b = 0;
    for(int i=1;i<=m;i++){
        if(o[i] == 1) k = k + (AND(A[i])*Shift(s[i]));
        else k = k + (AND(A[i]^BS)*Shift(s[i]));
        if(!o[i]) b ^= (AND(A[i])&BS);
    }
    b ^= B;
    return Node(k,b);
}
int n,q,__C;
int main(){
    Init();
    Rd(n),Rd(q),Rd(__C);
    for(int i=1;i<=n;i++){
        Rd(m);
        for(int j=1;j<=m;j++)
            Rd(s[j]),Rd(o[j]),Rd(A[j]);
        Rd(B);
        Val[i] = Trans();
    }
    T.build(1,n);
    while(q--){
        int op;Rd(op);
        if(op==0){
            int l,r;
            ull x;
            Rd(l),Rd(r),Rd(x);
            printf("%llu\n",T.Query(l,r,x));
        }else{
            int l;
            Rd(l),Rd(m);
            for(int j=1;j<=m;j++)
                Rd(s[j]),Rd(o[j]),Rd(A[j]);
            Rd(B);
            Val[l] = Trans();
            T.Update(l);
        }
    }
    return 0;
}