#include <bits/stdc++.h>

using i64 = long long;
using u64 = unsigned long long;

using Matrix = std::array<u64, 65>;

Matrix operator*(const Matrix &a, const Matrix &b) {
    Matrix c{};
    for (int i = 0; i <= 64; i++) {
        for (int j = 0; j <= 64; j++) {
            if (j == 64 || (a[i] >> j & 1)) {
                c[i] ^= b[j];
            }
        }
    }
    return c;
}

u64 operator*(u64 a, const Matrix &b) {
    u64 c = 0;
    for (int i = 0; i <= 64; i++) {
        if (i == 64 || (a >> i & 1)) {
            c ^= b[i];
        }
    }
    return c;
}

Matrix readMatrix() {
    int m;
    std::cin >> m;

    Matrix f{};
    for (int i = 0; i < m; i++) {
        int s, o;
        u64 A;
        std::cin >> s >> o >> A;

        if (o == 0) {
            for (int j = 0; j < 64; j++) {
                if (A >> ((j + s) % 64) & 1) {
                    f[64] ^= 1ULL << ((j + s) % 64);
                } else {
                    f[j] ^= 1ULL << ((j + s) % 64);
                }
            }
        } else {
            for (int j = 0; j < 64; j++) {
                if (A >> ((j + s) % 64) & 1) {
                    f[j] ^= 1ULL << ((j + s) % 64);
                }
            }
        }
    }

    u64 B;
    std::cin >> B;
    f[64] ^= B;

    return f;
}

constexpr int B = 100;

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    
    int N, Q, C;
    std::cin >> N >> Q >> C;

    std::vector<Matrix> f(N);
    for (int i = 0; i < N; i++) {
        f[i] = readMatrix();
    }

    int numBlock = (N + B - 1) / B;
    std::vector<Matrix> prod(numBlock);

    auto build = [&](int i) {
        int L = i * B;
        int R = std::min(N, L + B);
        for (int j = 0; j < 64; j++) {
            prod[i][j] = 1ULL << j;
        }
        for (int j = L; j < R; j++) {
            prod[i] = prod[i] * f[j];
        }
    };
    for (int i = 0; i < numBlock; i++) {
        build(i);
    }

    for (int i = 0; i < Q; i++) {
        int op;
        std::cin >> op;

        if (op == 0) {
            int l, r;
            u64 x;
            std::cin >> l >> r >> x;
            l--;

            if (l / B == (r - 1) / B) {
                for (int j = l; j < r; j++) {
                    x = x * f[j];
                }
            } else {
                int lb = l / B, rb = (r - 1) / B;
                for (int j = l; j < (lb + 1) * B; j++) {
                    x = x * f[j];
                }
                for (int j = lb + 1; j < rb; j++) {
                    x = x * prod[j];
                }
                for (int j = rb * B; j < r; j++) {
                    x = x * f[j];
                }
            }
            std::cout << x << "\n";
        } else {
            int l;
            std::cin >> l;
            l--;
            f[l] = readMatrix();
            build(l / B);
        }
    }
    
    return 0;
}