/*
 * d.cpp 2024-11-27
 * Copyright (C) 2024 Woshiluo Luo <[email protected]>
 *
 * 「Two roads diverged in a wood,and I—
 * I took the one less traveled by,
 * And that has made all the difference.」
 *
 * Distributed under terms of the GNU GNU AGPLv3+ license.
 */

#include <cstdio>
#include <cstdint>
#include <cstring>
#include <cstdlib>
#include <cinttypes>

#include <map>
#include <set>
#include <vector>
#include <algorithm>

using i32 = int32_t;
using u32 = uint32_t;
using ci32 = const int32_t;
using cu32 = const uint32_t;

using i64 = int64_t;
using u64 = uint64_t;
using ci64 = const int64_t;
using cu64 = const uint64_t;

inline bool isdigit( const char cur ) { return cur >= '0' && cur <= '9'; }/*{{{*/
template <class T> 
constexpr T Max( T a, T b ) { return a > b? a: b; }
template <class T> 
constexpr T Min( T a, T b ) { return a < b? a: b; }
template <class T> 
void chk_Max( T &a, T b ) { if( b > a ) a = b; }
template <class T> 
void chk_Min( T &a, T b ) { if( b < a ) a = b; }
template <typename T>
T read() { 
	T sum = 0, fl = 1; 
	char ch = getchar();
	for (; isdigit(ch) == 0; ch = getchar())
		if (ch == '-') fl = -1;
	for (; isdigit(ch); ch = getchar()) sum = sum * 10 + ( ch - '0' );
	return sum * fl;
}
template <class T> 
constexpr T pow( T a, i32 p ) {
	T res = 1;
	while( p ) {
		if( p & 1 ) 
			res = res * a;
		a = a * a;
		p >>= 1;
	}
	return res;
}/*}}}*/

const int BUF_LEN = 16;

char buf[BUF_LEN];

const i32 mod = 998244353;
const i32 LIMIT = 1e7;

template<i32 P>
struct ModInt {// {{{
    i32 x;
    constexpr ModInt() : x {0} {}
    constexpr ModInt(i64 _x) : x {norm(_x % get_mod())} {}
    
    static i32 mod;

    constexpr static i32 get_mod() { return P > 0? P: mod; }
    constexpr static void set_mod(i32 _mod) { mod = _mod; }

    static constexpr i32 norm(i32 x) {
        if (x < 0) {
            x += get_mod();
        }
        if (x >= get_mod()) {
            x -= get_mod();
        }
        return x;
    }
    constexpr i32 val() const { return x; }
    constexpr ModInt operator-() const {
        ModInt res;
        res.x = norm(get_mod() - x);
        return res;
    }

    constexpr ModInt inv() const { return pow(*this, get_mod() - 2); }

    constexpr ModInt& operator*=(const ModInt &rhs) & { x = (((i64)x) * rhs.x) % get_mod(); return *this; }
    constexpr ModInt& operator+=(const ModInt &rhs) & { x = norm(x + rhs.x); return *this; }
    constexpr ModInt& operator-=(const ModInt rhs) & { x = norm(x - rhs.x); return *this; }
    constexpr ModInt& operator/=(const ModInt rhs) & { return *this *= rhs.inv(); }

    friend constexpr ModInt operator*(const ModInt& lhs, const ModInt& rhs) { ModInt res = lhs; res *= rhs; return res; }
    friend constexpr ModInt operator+(const ModInt& lhs, const ModInt& rhs) { ModInt res = lhs; res += rhs; return res; }
    friend constexpr ModInt operator-(const ModInt& lhs, const ModInt& rhs) { ModInt res = lhs; res -= rhs; return res; }
    friend constexpr ModInt operator/(const ModInt& lhs, const ModInt& rhs) { ModInt res = lhs; res /= rhs; return res; }

    friend constexpr bool operator==(const ModInt& lhs, const ModInt& rhs) { return lhs.val() == rhs.val(); }
    friend constexpr bool operator!=(const ModInt& lhs, const ModInt& rhs) { return lhs.val() != rhs.val(); }
//    friend constexpr bool operator<(const ModInt& lhs, const ModInt& rhs) { return lhs.val() < rhs.val(); }
	void output( const char end = '\n' ) { printf( "%" PRId32 "%c", x, end ); }
};// }}} 

struct Inst {
	int type;
	// 0 halt
	// 1 push pop
	int a, x, b, y;
};
std::vector<Inst> insts;

void no_exit() {
	printf("-1\n" );
	std::exit(0);
}

// cnt, nxt
std::set<std::pair<i32, i32>> in_stack;
std::map<std::pair<i32, i32>, std::pair<ModInt<mod>, i32>> mp;
int dfs_cnt;
std::pair<ModInt<mod>, i32> dfs( ci32 cur, ci32 x ) {
	const auto cur_inst = insts[cur];
	const auto pair = std::make_pair( cur, x );
	if( cur_inst.type == 0 ) {
		if( x == 0 ) 
			return std::make_pair( 1, 0 );
	}
	if( in_stack.count(pair) ) {
		no_exit();
	}
	if( cur_inst.type == 1 ) {
		if( x == insts[cur].a ) {
			return std::make_pair( 1, insts[cur].x );
		}
	}
	dfs_cnt ++;
	if( dfs_cnt >= LIMIT ) {
		no_exit();
	}
	if( mp.count(pair) ) 
		return mp[pair];
	in_stack.insert(pair);
	ModInt<mod> cnt = 0;
	i32 ny = cur_inst.y, nb = cur_inst.b;
	{
		const auto nxt = dfs( ny, nb );
		if( nxt.second == 0 ) {
			mp[pair] = std::make_pair( nxt.first + 1, nxt.second );
			return mp[pair];
		}
		else {
			cnt += nxt.first;
			ny = nxt.second;
		}
	}
	{
		const auto nxt = dfs( ny, x );
		mp[pair] = std::make_pair( cnt + nxt.first + 1, nxt.second );
	}
	in_stack.erase(pair);
	return mp[pair];
}

int main() {
#ifdef woshiluo
	freopen( "d.in", "r", stdin );
	freopen( "d.out", "w", stdout );
#endif

	ci32 n = read<i32>();
	insts.push_back( (Inst) { 0, 0, 0, 0, 0 } );
	for( int i = 1; i <= n; i ++ ) {
		scanf( "%s", buf );
		if( buf[0] == 'H' ) {
			scanf( "%s", buf );
			ci32 a = read<i32>();
			scanf( "%s", buf );
			ci32 x = read<i32>();
			insts.push_back( (Inst){ 0, 0, 0, a, x } );
		}
		else {
			ci32 a = read<i32>();
			scanf( "%s", buf );
			ci32 x = read<i32>();
			scanf( "%s", buf );
			ci32 b = read<i32>();
			scanf( "%s", buf );
			ci32 y = read<i32>();
			insts.push_back( (Inst){ 1, a, x, b, y } );
		}
	}

	auto res = dfs( 1, 0 );
	res.first.output();
}