// This Code was made by Chinese_zjc_.
#include <bits/stdc++.h>
const int MOD = 998244353;
struct mint
{
    unsigned v;
    mint(unsigned v = 0) : v(v) {}
    mint operator-() const { return v ? MOD - v : v; }
    mint &operator+=(const mint &X) { return (v += X.v) >= MOD ? v -= MOD : v, *this; }
    mint &operator-=(const mint &X) { return (v += MOD - X.v) >= MOD ? v -= MOD : v, *this; }
    mint &operator*=(const mint &X) { return v = 1llu * v * X.v % MOD, *this; }
    mint &operator/=(const mint &X) { return *this *= X.inv(); }
    mint pow(long long B) const
    {
        B %= MOD - 1;
        if (B < 0)
            B += MOD - 1;
        mint res = 1, A = *this;
        while (B)
        {
            if (B & 1)
                res *= A;
            B >>= 1;
            A *= A;
        }
        return res;
    }
    mint inv() const { return pow(MOD - 2); }
    friend mint operator+(const mint &A, const mint &B) { return mint(A) += B; }
    friend mint operator-(const mint &A, const mint &B) { return mint(A) -= B; }
    friend mint operator*(const mint &A, const mint &B) { return mint(A) *= B; }
    friend mint operator/(const mint &A, const mint &B) { return mint(A) /= B; }
    friend std::istream &operator>>(std::istream &A, mint &B) { return A >> B.v; }
    friend std::ostream &operator<<(std::ostream &A, const mint &B) { return A << B.v; }
    explicit operator bool() const { return v; }
    friend bool operator==(const mint &A, const mint &B) { return A.v == B.v; }
} sgn = 1;
struct matrix
{
    mint v[3][3];
    friend matrix operator*(const matrix &A, const matrix &B)
    {
        matrix res;
        for (int i = 0; i != 3; ++i)
            for (int j = 0; j != 3; ++j)
                for (int k = 0; k != 3; ++k)
                    res.v[i][k] += A.v[i][j] * B.v[j][k];
        return res;
    }
} I, t[1 << 19];
struct vector
{
    mint x, y, z;
    matrix f()
    {
        matrix res;
        res.v[0][1] = z;
        res.v[0][2] = -y;
        res.v[1][2] = x;
        res.v[1][0] = -z;
        res.v[2][0] = y;
        res.v[2][1] = -x;
        return res;
    }
    vector operator*(const matrix &X) const
    {
        vector res;
        res.x = x * X.v[0][0] + y * X.v[0][1] + z * X.v[0][2];
        res.y = x * X.v[1][0] + y * X.v[1][1] + z * X.v[1][2];
        res.z = x * X.v[2][0] + y * X.v[2][1] + z * X.v[2][2];
        return res;
    }
    friend vector operator*(const mint &A, const vector &B)
    {
        vector res;
        res.x = A * B.x;
        res.y = A * B.y;
        res.z = A * B.z;
        return res;
    }
    friend std::istream &operator>>(std::istream &A, vector &B) { return A >> B.x >> B.y >> B.z; }
    friend std::ostream &operator<<(std::ostream &A, const vector &B) { return A << B.x << ' ' << B.y << ' ' << B.z; }
} v[200005];
int n, q, son[200005][2], siz[200005], top[200005], bot[200005], dfn[200005], idfn[200005], fa[200005];
char c[200005];
void init(int now)
{
    if (c[now] == 'x')
    {
        fa[son[now][0]] = fa[son[now][1]] = now;
        init(son[now][0]);
        init(son[now][1]);
        siz[now] = siz[son[now][0]] + siz[son[now][1]];
        if (siz[son[now][0]] < siz[son[now][1]])
            std::swap(son[now][0], son[now][1]), sgn = -sgn;
    }
    else
        siz[now] = 1;
}
void init2(int now)
{
    static int tim;
    idfn[dfn[now] = ++tim] = now;
    if (!top[now])
        top[now] = now;
    if (c[now] == 'x')
    {
        top[son[now][0]] = top[now];
        init2(son[now][0]);
        init2(son[now][1]);
        bot[now] = bot[son[now][0]];
        v[now] = v[son[now][0]] * v[son[now][1]].f();
    }
    else
        bot[now] = now;
}
#define lson (now << 1)
#define rson (lson | 1)
#define lmid ((l + r) >> 1)
#define rmid (lmid + 1)
void pushup(int now) { t[now] = t[lson] * t[rson]; }
void build(int now = 1, int l = 1, int r = n)
{
    if (l == r)
    {
        t[now] = v[son[idfn[l]][1]].f();
        return;
    }
    build(lson, l, lmid);
    build(rson, rmid, r);
    pushup(now);
}
matrix query(int L, int R, int now = 1, int l = 1, int r = n)
{
    if (R < l || r < L)
        return I;
    if (L <= l && r <= R)
        return t[now];
    return query(L, R, lson, l, lmid) * query(L, R, rson, rmid, r);
}
void modify(int pos, matrix val, int now = 1, int l = 1, int r = n)
{
    if (l == r)
        return void(t[now] = val);
    if (pos <= lmid)
        modify(pos, val, lson, l, lmid);
    else
        modify(pos, val, rson, rmid, r);
    pushup(now);
}
vector update(int now)
{
    while (top[now] != 1)
    {
        modify(dfn[fa[top[now]]], (v[bot[now]] * query(dfn[top[now]], dfn[bot[now]] - 1)).f());
        now = fa[top[now]];
    }
    return v[bot[now]] * query(dfn[top[now]], dfn[bot[now]] - 1);
}
signed main()
{
    I.v[0][0] = I.v[1][1] = I.v[2][2] = 1;
    std::ios::sync_with_stdio(false);
    std::cin >> n >> q;
    for (int i = 1; i <= n; ++i)
    {
        std::cin >> c[i];
        if (c[i] == 'x')
            std::cin >> son[i][0] >> son[i][1];
        else
            std::cin >> v[i];
    }
    init(1);
    init2(1);
    build();
    for (int i = 1, pos; i <= q; ++i)
    {
        std::cin >> pos >> v[pos];
        std::cout << sgn * update(pos) << std::endl;
    }
    return 0;
}