#include<bits/stdc++.h>
using std::cin, std::cout;
using ll = long long;
int n;

const int N = 26;
const int mod = 998244353;
using u64 = unsigned long long;
std::string l[N], r[N];
int op[N];
int m;

const int M = 11;

int edge[1 << M];
int dp[1 << M];
int mask[1 << M];
int min[M], max[M];
void inc(int & x, int y) {
	if((x += y) >= mod) {
		x -= mod;
	}
}
int solve(int n) {
	memset(mask, 0, 4 << n);
	memset(dp, 0, 4 << n);
	for(int i = 0;i < 1 << n;++i) {
		for(int j = 0;j < n;++j) if((i >> j & 1) == 0) {
			if((edge[j] & i) == edge[j]) {
				mask[i] |= 1 << j;
			}
		}
	}
	dp[0] = 1;
	for(int i = 0;i <= 9;++i) {
		int valid = 0;
		for(int j = 0;j < n;++j) if(min[j] <= i && i <= max[j]) {
			valid |= 1 << j;
		}
		for(int j = (1 << n) - 1;j >= 0;--j) if(int v = dp[j]) {
			int add = valid & mask[j];
			for(int k = add;k;k = (k - 1) & add) {
				inc(dp[j | k], v);
			}
		}
	}
	memset(edge, 0, n << 2);
	return dp[(1 << n) - 1];
}

struct graph {
	int l[N], r[N];
	int gt[N][N];
	int eq[N][N];
	int col[N];
	int colpb[N];

	int le[N], ri[N];
	int G[N][N];
	void lim(int x, int L, int R) {
		l[x] = std::max(l[x], L);
		r[x] = std::min(r[x], R);
	}
	void init() {
		for(int i = 0;i < N;++i) {
			l[i] = 0, r[i] = 9;
			le[i] = 0, ri[i] = 9;
			col[i] = -1;
			colpb[i] = -1;
		}
	}
	int solve() {
		static std::queue<int> Q;
		int cc = 0;
		for(int i = 0;i < N;++i) if(col[i] == -1) {
			col[i] = cc; Q.push(i);
			for(;Q.size();) {
				int x = Q.front(); Q.pop();
				for(int j = 0;j < N;++j) if(eq[x][j] && col[j] == -1) {
					col[j] = cc; Q.push(j);
				}
			}
			++cc;
		}
		for(int i = 0;i < N;++i) {
			le[col[i]] = std::max(le[col[i]], l[i]);
			ri[col[i]] = std::min(ri[col[i]], r[i]);
			for(int j = 0;j < N;++j) if(gt[i][j]) {
				G[col[i]][col[j]] = 1;
			}
		}
		for(int i = 0;i < cc;++i) col[i] = -1;
		int res = 1;

		for(int i = 0;i < cc;++i) if(col[i] == -1) {
			static std::vector<int> con; 
			col[i] = 0; Q.push(i); con = {i};
			for(;Q.size();) {
				int x = Q.front(); Q.pop();
				for(int j = 0;j < cc;++j) if((G[x][j] || G[j][x]) && col[j] == -1) {
					col[j] = 0; Q.push(j);
					con.push_back(j);
				}
			}
			int m = con.size();
			for(int i = 0;i < m;++i) {
				min[i] = le[con[i]];
				max[i] = ri[con[i]];
				for(int j = 0;j < m;++j) {
					edge[i] |= G[con[i]][con[j]] << j;
				}
			}
			res = (u64) res * ::solve(m) % mod;
		}

		return res;
	}
} G;

int ans;
void dfs0(int x, graph t) {
	if(x == m) {
		inc(ans, t.solve());
		return ;
	}
	for(int lcp = 0;lcp < (int) l[x].size();++lcp) {
		graph z = t;
		int bad = 0;
		for(int j = 0;j < lcp;++j) {
			int a = isalpha(l[x][j]);
			int b = isalpha(r[x][j]);
			if(a && b) {
				z.eq[l[x][j] - 'A'][r[x][j] - 'A'] = 1;
				z.eq[r[x][j] - 'A'][l[x][j] - 'A'] = 1;
			}
			if(!a && !b) {
				if(l[x][j] != r[x][j]) {
					bad = 1;
					break;
				}
			}
			char A = l[x][j], B = r[x][j];
			if(a && !b) z.lim(A - 'A', B - '0', B - '0');
			if(!a && b) z.lim(B - 'A', A - '0', A - '0');
		}
		if(bad) continue;
		int a = isalpha(l[x][lcp]);
		int b = isalpha(r[x][lcp]);
		if(!a && !b) {
			if(l[x][lcp] <= r[x][lcp]) {
				continue;
			}
		} else if(a && b) {
			z.gt[l[x][lcp] - 'A'][r[x][lcp] - 'A'] = 1;
		} else if(a && !b) {
			z.lim(l[x][lcp] - 'A', r[x][lcp] - '0' + 1, 9);
		} else if(!a && b) {
			z.lim(r[x][lcp] - 'A', 0, l[x][lcp] - '0' - 1);
		}
		dfs0(x + 1, z);
	}
}
int main() {
	std::ios::sync_with_stdio(false), cin.tie(0);
	cin >> n;
	G.init();
	for(int i = 0;i < n;++i) {
		std::string s, l, r;
		char op;
		cin >> s;
		for(int i = 0;i < (int) s.size();++i) {
			if(s[i] == '=' || s[i] == '<' || s[i] == '>') {
				op = s[i];
				l = std::string(s.begin(), s.begin() + i);
				r = std::string(s.begin() + i + 1, s.end());
			}
		}
		for(;l.size() < r.size();) l = "0" + l;
		for(;l.size() > r.size();) r = "0" + r;
		if(op == '=') {
			for(int j = 0;j < (int) l.size();++j) {
				int a = isalpha(l[j]);
				int b = isalpha(r[j]);
				if(a && b) {
					G.eq[l[j] - 'A'][r[j] - 'A'] = 1;
					G.eq[r[j] - 'A'][l[j] - 'A'] = 1;
				}
				if(!a && !b) {
					if(l[j] != r[j]) {
						puts("0");
						return 0;
					}
				}
				if(b) std::swap(l[j], r[j]), std::swap(a, b);
				if(a && !b) {
					G.lim(l[j] - 'A', r[j] - '0', r[j] - '0');
				}
			}
		} else {
			if(op == '<') op = '>', std::swap(l, r);
			::l[m] = l;
			::r[m] = r;
			::op[m++] = op;
		}
	}

	dfs0(0, G);

	cout << ans << '\n';
}