#include <map>
#include <set>
#include <array>
#include <cmath>
#include <deque>
#include <bitset>
#include <random>
#include <string>
#include <vector>
#include <cassert>
#include <complex>
#include <iomanip>
#include <iostream>
#include <algorithm>
#include <unordered_map>
#include <unordered_set>

using namespace std;

#define ull unsigned long long

const int K = 64;

struct Matrix{
    ull vals[K];
    Matrix() {
        fill(vals, vals + K, 0ULL);
    }
};

ull combine(ull a, ull b) {
    return (__builtin_popcountll(a & b) & 1ULL);
}

ull operator*(const Matrix& A, ull b) {
    ull ans = 0;
    for (int i = 0; i < K; ++i) {
        ans ^= (combine(A.vals[i], b) << i);
    }
    return ans;
}

Matrix operator*(const Matrix& A, const Matrix& B) {
    Matrix ans;
    for (int i = 0; i < K; ++i) {
        ull column = 0;
        for (int j = 0; j < K; ++j)
            column ^= ((B.vals[j] >> i) & 1ULL) << j;
        ull new_column = A * column;
        for (int j = 0; j < K; ++j)
            ans.vals[j] ^= ((new_column >> j) & 1ULL) << i;
    }
    return ans;
}

struct Node {
    Matrix matrix;
    ull intercept;
};

Node nodes[(1 << 17) + 228];

void recalc(int v) {
    nodes[v].matrix = nodes[2 * v + 2].matrix * nodes[2 * v + 1].matrix;
    nodes[v].intercept = nodes[2 * v + 2].intercept ^ (nodes[2 * v + 2].matrix * nodes[2 * v + 1].intercept);
}

void build(int v, int left, int right, vector<Matrix>& A, vector<ull>& b) {
    if (left + 1 == right) {
        nodes[v].matrix = A[left];
        nodes[v].intercept = b[left];
        return;
    }
    int mid = (left + right) / 2;
    build(2 * v + 1, left, mid, A, b);
    build(2 * v + 2, mid, right, A, b);
    recalc(v);
}

ull get(int v, int left, int right, int x, int y, ull val) {
    if (y <= left || right <= x)
        return val;
    if (x <= left && right <= y) {
        return (nodes[v].matrix * val) ^ nodes[v].intercept;
    }
    int mid = (left + right) / 2;
    ull val_mid = get(2 * v + 1, left, mid, x, y, val);
    return get(2 * v + 2, mid, right, x, y, val_mid);
}

void upd(int v, int left, int right, int i, Matrix& new_matrix, ull new_intercept) {
    if (left + 1 == right) {
        nodes[v].matrix = new_matrix;
        nodes[v].intercept = new_intercept;
        return;
    }
    int mid = (left + right) / 2;
    if (i < mid)
        upd(2 * v + 1, left, mid, i, new_matrix, new_intercept);
    else
        upd(2 * v + 2, mid, right, i, new_matrix, new_intercept);
    recalc(v);
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    
    int n, q, c;
    cin >> n >> q >> c;
    vector<Matrix> A(n);
    vector<ull> b(n);

    auto read_op = []() {
        Matrix res;
        ull inter = 0;
        int m;
        cin >> m;
        while (m--) {
            int s, o;
            cin >> s >> o;
            ull x;
            cin >> x;
            if (o == 0) {
                // or
                for (int j = 0; j < K; ++j) {
                    int to_bit = (j + s) % K;
                    if (x & (1ULL << to_bit))
                        inter ^= 1ULL << to_bit;
                    else
                        res.vals[to_bit] ^= 1ULL << j;
                }
            } else {
                // and
                for (int j = 0; j < K; ++j) {
                    int to_bit = (j + s) % K;
                    if (x & (1ULL << to_bit))
                        res.vals[to_bit] ^= 1ULL << j;
                }
            }
        }
        ull delta;
        cin >> delta;
        inter ^= delta;
        return make_pair(res, inter);
    };

    for (int i = 0; i < n; ++i) {
        auto tmp = read_op();
        A[i] = tmp.first;
        b[i] = tmp.second;
    }
    build(0, 0, n, A, b);
    while (q--) {
        int op;
        cin >> op;
        if (op == 0) {
            int l, r;
            cin >> l >> r;
            ull x;
            cin >> x;
            cout << get(0, 0, n, l - 1, r, x) << '\n';
        } else {
            int l;
            cin >> l;
            auto tmp = read_op();
            upd(0, 0, n, l - 1, tmp.first, tmp.second);
        }
    }
    return 0;
}