#include <bits/stdc++.h>
#define rep(i,x,y) for(int i = x; i <= y; i++)
#define mid ((l + r) >> 1)
#define lch (rt << 1)
#define rch (rt << 1 | 1)

using namespace std;

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

int getint() {
    char ch;
    while (!isdigit(ch = getchar()));
    int x = ch - 48;
    while (isdigit(ch = getchar())) x = x * 10 + ch - 48;
    return x;
}

using u32 = unsigned;
using i64 = long long;
using u64 = unsigned long long;
 
// TODO: Dynamic ModInt
 
template<typename T>
constexpr T power(T a, u64 b) {
    T res {1};
    for (; b != 0; b /= 2, a *= a) {
        if (b % 2 == 1) {
            res *= a;
        }
    }
    return res;
}
 
template<u32 P>
constexpr u32 mulMod(u32 a, u32 b) {
    return 1ULL * a * b % P;
}
 
template<u64 P>
constexpr u64 mulMod(u64 a, u64 b) {
    u64 res = a * b - u64(1.L * a * b / P - 0.5L) * P;
    res %= P;
    return res;
}
 
template<typename U, U P>
struct ModIntBase {
public:
    constexpr ModIntBase() : x {0} {}
    
    template<typename T>
    constexpr ModIntBase(T x_) : x {norm(x_ % T {P})} {}
    
    constexpr static U norm(U x) {
        if ((x >> (8 * sizeof(U) - 1) & 1) == 1) {
            x += P;
        }
        if (x >= P) {
            x -= P;
        }
        return x;
    }
    
    constexpr U val() const {
        return x;
    }
    
    constexpr ModIntBase operator-() const {
        ModIntBase res;
        res.x = norm(P - x);
        return res;
    }
    
    constexpr ModIntBase inv() const {
        return power(*this, P - 2);
    }
    
    constexpr ModIntBase &operator*=(const ModIntBase &rhs) & {
        x = mulMod<P>(x, rhs.val());
        return *this;
    }
    
    constexpr ModIntBase &operator+=(const ModIntBase &rhs) & {
        x = norm(x + rhs.x);
        return *this;
    }
    
    constexpr ModIntBase &operator-=(const ModIntBase &rhs) & {
        x = norm(x - rhs.x);
        return *this;
    }
    
    constexpr ModIntBase &operator/=(const ModIntBase &rhs) & {
        return *this *= rhs.inv();
    }
    
    friend constexpr ModIntBase operator*(ModIntBase lhs, const ModIntBase &rhs) {
        lhs *= rhs;
        return lhs;
    }
    
    friend constexpr ModIntBase operator+(ModIntBase lhs, const ModIntBase &rhs) {
        lhs += rhs;
        return lhs;
    }
    
    friend constexpr ModIntBase operator-(ModIntBase lhs, const ModIntBase &rhs) {
        lhs -= rhs;
        return lhs;
    }
    
    friend constexpr ModIntBase operator/(ModIntBase lhs, const ModIntBase &rhs) {
        lhs /= rhs;
        return lhs;
    }

    friend constexpr std::ostream &operator<<(std::ostream &os, const ModIntBase &a) {
        return os << a.val();
    }
    
    friend constexpr bool operator==(ModIntBase lhs, ModIntBase rhs) {
        return lhs.val() == rhs.val();
    }
    
    friend constexpr bool operator!=(ModIntBase lhs, ModIntBase rhs) {
        return lhs.val() != rhs.val();
    }
    
    friend constexpr bool operator<(ModIntBase lhs, ModIntBase rhs) {
        return lhs.val() < rhs.val();
    }
    
private:
    U x;
};
 
template<u32 P>
using ModInt = ModIntBase<u32, P>;
 
template<u64 P>
using ModInt64 = ModIntBase<u64, P>;
 
constexpr u32 P = 998244353;

using Z = ModInt<P>;

int main() {
    
    int n = getint();
    vector<vector<int>> ins(n);
    rep(i,0,n-1) {
        char s[10];
        scanf("%s", s);
        if (s[0] == 'P') {
            ins[i].resize(4);
            rep(j,0,3) ins[i][j] = getint();
        } else {
            ins[i].resize(2);
            rep(j,0,1) ins[i][j] = getint();
        }
    }
    
    if (ins[0].size() == 2) {
        cout << 1 << '\n';
        return 0;
    }

    for (auto& i : ins) for (auto& j : i) j--;

    Z ans = 0;
    vector<int> vis(n);
    vector<vector<int>> to(n, vector<int>(1024, -1));
    vector<vector<Z>> f(n, vector<Z>(1024));
    
    auto dfs2 = [&](auto& self, int now, int lst) -> void {
        if (to[now][lst] == -2) {
            cout << -1 << '\n';
            exit(0);
        }
        if (to[now][lst] != -1) {
            return;
        }
        to[now][lst] = -2;
        if (ins[now].size() == 4) {
            int a = ins[now][0], x = ins[now][1], b = ins[now][2], y = ins[now][3];
            if (a == lst) {
                to[now][lst] = x;
                f[now][lst] = 1;
            } else {
                self(self, y, b);
                self(self, to[y][b], lst);
                to[now][lst] = to[to[y][b]][lst];
                f[now][lst] = 1 + f[y][b] + f[to[y][b]][lst];
            }
        } else {
            int b = ins[now][0], y = ins[now][1];
            self(self, y, b);
            self(self, to[y][b], lst);
            to[now][lst] = to[to[y][b]][lst];
            f[now][lst] = 1 + f[y][b] + f[to[y][b]][lst];
        }
    };

    auto dfs1 = [&](auto& self, int now) -> void {
        if (vis[now]) {
            cout << -1 << '\n';
            exit(0);
        }

        vis[now] = 1;
        if (ins[now].size() == 2) {
            cout << ans + 1 << '\n';
            exit(0);
        }
      
        int b = ins[now][2], y = ins[now][3];
        dfs2(dfs2, y, b);
        ans += 1 + f[y][b];
        self(self, to[y][b]);
    };
    dfs1(dfs1, 0);

    return 0;
}