#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;

// #define Debug

const int N = 1e5;
const int Base = 10001, V = 26 * Base, Lg = 18;//logV 
const long long P = 998244353;

int n;
int id[N + 5];

int c[N + 5], x[N + 5];

int head[N + 5], to[N + 5], nxt[N + 5], edge = 1;
void add_edge(int u, int v)
{
	edge++;
	to[edge] = v;
	nxt[edge] = head[u];
	head[u] = edge;
	return ;
}

namespace SegF
{
	const int SZ = N * Lg * 2;//at most modify N times, not V
	struct Node
	{
		int ls, rs, nxt;
	} node[SZ + 5];
	int tot;

	#define ls(p) node[p].ls
	#define rs(p) node[p].rs
	#define nxt(p) node[p].nxt

	int newnode()
	{
		return ++tot;
	}

	void modify(int p, int q, int l, int r, int pos, int val)
	{
		if (l == r)
			return nxt(p) = val, void();

		int mid = (l + r) >> 1;
		node[p] = node[q];

		if (pos <= mid)
		{
			ls(p) = newnode();
			modify(ls(p), ls(q), l, mid, pos, val);
		}
		else
		{
			rs(p) = newnode();
			modify(rs(p), rs(q), mid + 1, r, pos, val);
		}
		return ;
	}
	int query(int p, int l, int r, int pos)
	{
		if (l == r)
			return nxt(p);

		int mid = (l + r) >> 1;
		if (pos <= mid)
			return query(ls(p), l, mid, pos);
		return query(rs(p), mid + 1, r, pos);
	}

	#undef ls
	#undef rs
	#undef nxt
}

namespace SegG
{
	const int SZ = N * Lg * 10;
	struct Node
	{
		int ls, rs;
		int len, sum;
		int tag;
	} node[SZ + 5];
	int tot;

	#define ls(p) node[p].ls
	#define rs(p) node[p].rs
	#define len(p) node[p].len
	#define sum(p) node[p].sum
	#define tag(p) node[p].tag

	int newnode(int length)
	{
		int p = ++tot;
		len(p) = length;
		return p;
	}
	int copy(int p)
	{
		int np = ++tot;
		node[np] = node[p];
		return np;
	}

	void pushup(int p)
	{
		sum(p) = (sum(ls(p)) + sum(rs(p))) % P;
		return ;
	}
	void cover(int p, int val)
	{
		tag(p) = val;
		sum(p) = 1ll * len(p) * val % P;
		return ;
	}
	void pushdown(int p, int l, int r)
	{
		if (!tag(p))
			return ;

		int mid = (l + r) >> 1;

		if (!ls(p))
			ls(p) = newnode(mid - l + 1);
		else
			ls(p) = copy(ls(p));

		if (!rs(p))
			rs(p) = newnode(r - mid);
		else
			rs(p) = copy(rs(p));

		cover(ls(p), tag(p));
		cover(rs(p), tag(p));
		tag(p) = 0;
		return ;
	}

	void modify(int p, int q, int l, int r, int L, int R, int val)
	{
		// node[p] = node[q];

		#ifdef Debug
		if (len(p) != r - l + 1)
		{
			cerr << "Error" << endl;
			exit(0);
		}
		#endif

		ls(p) = ls(q), rs(p) = rs(q);

		if (L <= l && r <= R)
		{

			cover(p, val);

			#ifdef Debug
			if (val == 717479)
			{
				cerr << p << " " << q << " " << l << " " << r << " " << L << " " << R << " " << val << endl;
				cerr << tag(p) << " === " << tag(q) << endl;
				cerr << len(p) << " --- " << len(q) << endl;
				cerr << "sum = " << sum(p) << endl;
				cerr << "^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^" << endl;
				cerr << endl;
			}
			#endif

			return ;

			// return cover(p, val), void();
		}

		int mid = (l + r) >> 1;
		pushdown(q, l, r);

		ls(p) = ls(q), rs(p) = rs(q);

		if (L <= mid)
		{
			ls(p) = newnode(mid - l + 1);
			
			modify(ls(p), ls(q), l, mid, L, R, val);
		}
		if (R > mid)
		{
			rs(p) = newnode(r - mid);
			modify(rs(p), rs(q), mid + 1, r, L, R, val);
		}
		pushup(p);


		#ifdef Debug
		if (val == 717479)
		{
			cerr << p << " " << q << " " << l << " " << r << " " << L << " " << R << " " << val << endl;
			cerr << tag(p) << " === " << tag(q) << endl;
			cerr << len(p) << " --- " << len(q) << endl;
			cerr << "sum = " << sum(p) << endl;
			cerr << endl;

			if (p == 5155)
			{
				cerr << ls(p) << " " << rs(p) << endl;
				cerr << sum(ls(p)) << " " << sum(rs(p)) << endl;
			}
		}
		#endif

		return ;
	}
	int query(int p, int l, int r, int L, int R)
	{

		#ifdef Debug
		if (L == 4 * Base + 1 && R == 4 * Base + 4008)
		{
			cerr << p << " " << l << " " << r << " " << L << " " << R << endl;
			cerr << len(p) << " " << sum(p) << endl;
			cerr << ls(p) << " " << rs(p) << endl;
			cerr << tag(p) << endl;
			cerr << endl;
		}
		#endif

		if (L <= l && r <= R)
			return sum(p);
		
		int mid = (l + r) >> 1, res = 0;


		#ifdef Debug
		if (mid - l + 1 > r - mid)
		{
			// cerr << l << " ================================= " << r << endl;
			// exit(0);
		}
		#endif

		pushdown(p, l, r);

		if (L <= mid && ls(p))
			res = query(ls(p), l, mid, L, R);
		if (R > mid && rs(p))
			res = (res + query(rs(p), mid + 1, r, L, R)) % P;
		return res;
	}

	void checkSeg(int p, int l, int r)
	{
		if (!p)
			return ;
		if (len(p) != r - l + 1)
		{
			cerr << "len != r - l + 1 !!!! Error" << endl;
			cerr << p << endl;
			exit(0);
		}
		if (l == r)
			return ;
		int mid = (l + r) >> 1;
		checkSeg(ls(p), l, mid);
		checkSeg(rs(p), mid + 1, r);
		return ;
	}

	#undef ls
	#undef rs
}

int ans[N + 5];

int rootF[N + 5], rootG[N + 5];
int mx[N + 5][30];

int calc(int length)
{
	return 1ll * length * (length + 1) / 2 % P;
}

void dfs(int u, int fa, int rt, int len)
{
	int zero = (c[u] - 1) * Base, pos = zero + x[u];

	int match = min(x[u], mx[fa][c[u]]);
	
	int fail = SegF :: query(rootF[fa], 1, V, pos);
	if (!fail && u != rt && c[u] == c[rt] && x[rt] < x[u])
		fail = rt;
	
	ans[u] = SegG :: query(rootG[fa], 1, V, zero + 1, pos);

	#ifdef Debug

	if (u > 686)
	{
		int res = SegG :: query(rootG[685], 1, V, 4 * Base + 1, 4 * Base + 4008);
		if (res != 402858218)
		{
			cerr << u << " error" << endl;
			exit(0);
		}
	}

	if (u == 823)
	{
		cerr << "rootG[fa] = " << rootG[fa] << endl;
		cerr << "ans = " << ans[u] << endl;
	}
	#endif

	ans[u] = (ans[u] + calc(match)) % P;

	#ifdef Debug
	#endif

	if (x[u] > match)//which means, x[rt] < x[u] if c[rt] = c[u]
	{
		if (u == rt)
			ans[u] = calc(x[u] - 1);
		else if (c[u] == c[rt])
			ans[u] = (ans[u] + 1ll * (x[u] - match) * x[rt] % P) % P;
		else
			{;}
	}

	#ifdef Debug
	if (u == 823)
	{
		cerr << ans[u] << endl;
	}
	#endif

	ans[u] = (ans[u] + ans[fa]) % P;

	#ifdef Debug
	if (u == 823)
	{
		cerr << ans[u] << endl;
	}
	#endif

	mx[fa][c[u]] = max(mx[fa][c[u]], x[u]);

	int tmp = rootF[fa];
	rootF[fa] = SegF :: newnode();
	SegF :: modify(rootF[fa], tmp, 1, V, pos, u);

	tmp = rootG[fa];
	rootG[fa] = SegG :: newnode(V);
	SegG :: modify(rootG[fa], tmp, 1, V, zero + 1, pos, len);

	#ifdef Debug
	if (u == 138)
	{
		cerr << u << ":" << endl;
		cerr << "tmp: " << tmp << endl;
		cerr << "modify: " << rootG[fa] << " " << tmp << " " << 1 << " " << V << " " <<
		zero + 1 << " " << pos << " " << len << endl;
		cerr << 4 * Base + 1 << " " << 4 * Base + 4008 << endl;
		cerr << "query::: " << SegG :: query(rootG[fa], 1, V, 4 * Base + 1, 4 * Base + 4008) << endl;

		cerr << SegF :: tot << " " << SegG :: tot << endl;
		SegG :: checkSeg(rootG[fa], 1, V);
		exit(0);
	}
	#endif

	for (int i = head[u]; i; i = nxt[i])
	{
		int v = to[i];

		memcpy(mx[u], mx[fail], sizeof(mx[u]));
		rootF[u] = rootF[fail];
		rootG[u] = rootG[fail];

		dfs(v, u, rt, len + x[u]);
	}
	return ;
}

int main()
{
	// freopen("jojo6.in", "r", stdin);
	// freopen("jojo.out", "w", stdout);

	scanf("%d", &n);
	for (int i = 1, opt; i <= n; i++)
	{
		scanf("%d", &opt);
		if (opt == 1)
		{
			char tmp;
			scanf("%d %c", x + i, &tmp);
			c[i] = tmp - 'a' + 1;

			id[i] = i;
			add_edge(id[i - 1], id[i]);
		}
		else
		{
			scanf("%d", x + i);
			id[i] = id[x[i]];
		}

		#ifdef Debug
		if (i == 823)
			break;
		#endif
	}

	for (int i = head[0]; i; i = nxt[i])
	{
		int v = to[i];
		
		rootF[0] = rootG[0] = 0;
		memset(mx[0], 0, sizeof(mx[0]));

		dfs(v, 0, v, 0);
	}
	for (int i = 1; i <= n; i++)
		printf("%d\n", ans[id[i]]);
	return 0;
}