#include <bits/stdc++.h>

using i64 = long long;

using TransBit = std::array<int, 16>;
using Trans = std::array<TransBit, 8>;

Trans identity() {
    Trans t;
    for (int i = 0; i < 8; i++) {
        std::iota(t[i].begin(), t[i].end(), 0);
    }
    return t;
}

Trans operator*(const Trans &a, const Trans &b) {
    Trans c;
    for (int i = 0; i < 8; i++) {
        for (int j = 0; j < 16; j++) {
            c[i][j] = b[i][a[i][j]];
        }
    }
    return c;
}

Trans get(std::string o, int x, int y) {
    Trans t;
    for (int i = 0; i < 8; i++) {
        for (int a = 0; a < 16; a++) {
            int vx = a >> x & 1;
            int vy = a >> y & 1;
            int b = a ^ (vx << x);
            int v;
            if (o == "or") {
                v = vx | vy;
            } else if (o == "and") {
                v = vx & vy;
            } else {
                v = vx ^ vy;
            }
            b ^= v << x;
            t[i][a] = b;
        }
    }
    return t;
}

Trans geti(std::string o, int x, int y) {
    Trans t;
    for (int i = 0; i < 8; i++) {
        for (int a = 0; a < 16; a++) {
            int vx = a >> x & 1;
            int vy = y >> i & 1;
            int b = a ^ (vx << x);
            int v;
            if (o == "ori") {
                v = vx | vy;
            } else if (o == "andi") {
                v = vx & vy;
            } else {
                v = vx ^ vy;
            }
            b ^= v << x;
            t[i][a] = b;
        }
    }
    return t;
}

Trans power(Trans a, int b) {
    Trans res = identity();
    for (; b; b /= 2, a = a * a) {
        if (b % 2) {
            res = res * a;
        }
    }
    return res;
}

std::array<int, 4> trans(std::array<int, 4> a, Trans t) {
    std::array<int, 4> ans{};
    for (int i = 0; i < 8; i++) {
        int mask = 0;
        for (int j = 0; j < 4; j++) {
            mask |= (a[j] >> i & 1) << j;
        }
        mask = t[i][mask];
        for (int j = 0; j < 4; j++) {
            ans[j] |= (mask >> j & 1) << i;
        }
    }
    return ans;
}

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);

    int n, q;
    std::cin >> n >> q;

    constexpr int inf = 1E9 + 1;

    std::vector<int> path{0};
    std::vector<Trans> val{identity()};
    std::vector<int> rep{1};
    std::vector<std::vector<int>> adj(1);
    std::vector<int> cnt{0};

    int tot = 1;
    for (int i = 0; i < n; i++) {
        std::string ins;
        std::cin >> ins;

        if (ins == "repeat") {
            int m;
            std::cin >> m;
            path.push_back(tot++);
            val.push_back(identity());
            rep.push_back(m);
            adj.push_back({});
            cnt.push_back(0);
        } else if (ins == "end") {
            int x = path.back();
            path.pop_back();
            int y = path.back();
            adj[y].push_back(x);
            val[y] = val[y] * power(val[x], rep[x]);
            cnt[y] = std::min(1LL * inf, cnt[y] + 1LL * cnt[x] * rep[x]);
        } else if (ins.back() == 'i') {
            std::string x;
            std::cin >> x;
            int y;
            std::cin >> y;

            int u = path.back();
            int v = tot++;
            val.push_back(geti(ins, x[0] - 'a', y));
            rep.push_back(1);
            adj.push_back({});
            cnt.push_back(1);
            adj[u].push_back(v);
            val[u] = val[u] * val[v];
            cnt[u] = std::min(inf, cnt[u] + 1);
        } else {
            std::string x, y;
            std::cin >> x >> y;

            int u = path.back();
            int v = tot++;
            val.push_back(get(ins, x[0] - 'a', y[0] - 'a'));
            rep.push_back(1);
            adj.push_back({});
            cnt.push_back(1);
            adj[u].push_back(v);
            val[u] = val[u] * val[v];
            cnt[u] = std::min(inf, cnt[u] + 1);
        }
    }

    auto dfs = [&](auto self, int x) -> void {
        std::vector<int> tmp;
        int u = x, i = 0;
        while (i < adj[u].size()) {
            int y = adj[u][i];
            if (cnt[y] < inf) {
                tmp.push_back(y);
                i++;
            } else {
                u = y, i = 0;
            }
        }
        adj[x] = std::move(tmp);
        for (auto y : adj[x]) {
            self(self, y);
        }
    };
    dfs(dfs, 0);

    std::vector<std::vector<int>> prec(tot);
    std::vector<std::vector<Trans>> prev(tot);
    for (int i = 0; i < tot; i++) {
        prec[i].resize(adj[i].size() + 1);
        prev[i].resize(adj[i].size() + 1);
        prev[i][0] = identity();
        for (int j = 0; j < adj[i].size(); j++) {
            int x = adj[i][j];
            prec[i][j + 1] = std::min(1LL * inf, prec[i][j] + 1LL * rep[x] * cnt[x]);
            prev[i][j + 1] = prev[i][j] * power(val[x], rep[x]);
        }
    }
    
    for (int i = 0; i < q; i++) {
        int k;
        std::cin >> k;
        std::array<int, 4> v;
        for (int j = 0; j < 4; j++) {
            std::cin >> v[j];
        }

        int x = 0;
        while (k > 0) {
            int j = std::upper_bound(prec[x].begin(), prec[x].end(), k) - prec[x].begin() - 1;
            k -= prec[x][j];
            v = trans(v, prev[x][j]);
            if (k == 0) {
                break;
            }
            x = adj[x][j];
            v = trans(v, power(val[x], k / cnt[x]));
            k %= cnt[x];
        }

        for (int j = 0; j < 4; j++) {
            std::cout << v[j] << " \n"[j == 3];
        }
    }

    return 0;
}