#include <map>
#include <set>
#include <array>
#include <cmath>
#include <deque>
#include <bitset>
#include <random>
#include <string>
#include <vector>
#include <cassert>
#include <complex>
#include <iomanip>
#include <iostream>
#include <algorithm>
#include <unordered_map>
#include <unordered_set>

using namespace std;

const int MOD = 998244353;

int add(int a, int b) {
    return a + b >= MOD ? a + b - MOD : a + b;
}

int sub(int a, int b) {
    return a >= b ? a - b : a + MOD - b;
}

int mul(int a, int b) {
    return (1ll * a * b) % MOD;
}

int pw(int x, int n) {
    int res = 1;
    while (n) {
        if (n % 2 == 0) {
            x = mul(x, x);
            n /= 2;
        } else {
            res = mul(res, x);
            --n;
        }
    }
    return res;
}


const int N = 11;
const int MAXN = 100;
int dp[(1 << N) + 228];

vector<int> G[MAXN];
bool used[MAXN];
vector<int> order;

void dfs(int v) {
    used[v] = true;
    for (int u : G[v]) {
        if (!used[u])
            dfs(u);
    }
    order.emplace_back(v);
}

const int DIGITS = 10;
const int ALPHA = 26;

int solve_g(int n, const vector<int>& should, const vector<pair<int, int>>& edges) {
    /*cerr << n << '\n';
    for (int i = 0; i < n; ++i)
        cerr << should[i] << ' ';
    cerr << '\n';
    for (auto [a, b] : edges)
        cerr << a << '<' << b << ' ';
    cerr << '\n';*/
    // (a, b) means a < b
    fill(used, used + n, false);
    for (auto [a, b] : edges) {
        G[b].emplace_back(a);
    }
    for (int i = 0; i < n; ++i) {
        if (!used[i])
            dfs(i);
    }
    reverse(order.begin(), order.end());
    /*for (int v : order)
        cout << v << ' ';
    cout << '\n';*/
    // edges a -> b
    vector<int> id(n);
    for (int i = 0; i < n; ++i)
        id[order[i]] = i;
    vector<int> mask_less(n);
    vector<int> mask_more(n);
    for (auto [a, b] : edges) {
        mask_more[id[a]] |= 1 << id[b];
        mask_less[id[b]] |= 1 << id[a];
    }
    fill(dp, dp + (1 << n), 0);
    dp[0] = 1;
    for (int digit = 0; digit < DIGITS; ++digit) {
        for (int v = 0; v < n; ++v) {
            if (should[order[v]] != -1 && should[order[v]] != digit)
                continue;
            for (int mask = 0; mask < (1 << n); ++mask) {
                if (mask & (1 << v)) {
                    if ((mask & mask_less[v]) == mask_less[v] && (mask & mask_more[v]) == 0)
                        dp[mask] = add(dp[mask], dp[mask ^ (1 << v)]);
                }
            }
        }
        /*cout << digit << ":\n";
        for (int mask = 0; mask < (1 << n); ++mask)
            cout << dp[mask] << ' ';
        cout << '\n';*/
    }
    for (int i = 0; i < n; ++i)
        G[i].clear();
    order.clear();
    //cerr << "dp: " << dp[(1 << n) - 1] << '\n' << '\n';
    return dp[(1 << n) - 1];
}


int par[DIGITS + ALPHA];

int get(int v) {
    if (par[v] == v)
        return v;
    return par[v] = get(par[v]);
}

bool merge(int v, int u) {
    v = get(v);
    u = get(u);
    if (v == u)
        return false;
    par[v] = u;
    return true;
}

vector<int> G2[MAXN];
bool used2[MAXN];
vector<int> comp;

void dfs2(int v) {
    used2[v] = true;
    comp.emplace_back(v);
    for (int u : G2[v]) {
        if (!used2[u])
            dfs2(u);
    }
}


int solve(const vector<pair<bool, pair<int, int>>>& eqs) {
    // false: a < b
    // true: a = b
    // 0 ... 9 - real numbers
    // 10 ... 35 - letters
    iota(par, par + DIGITS + ALPHA, 0);
    for (auto [type, ab] : eqs) {
        auto [a, b] = ab;
        if (type) {
            merge(a, b);
        }
    }
    for (int i = 0; i < DIGITS; ++i) {
        for (int j = i + 1; j < DIGITS; ++j) {
            if (get(i) == get(j))
                return 0;
        }
    }
    vector<pair<int, int>> edges;
    for (auto [type, ab] : eqs) {
        auto [a, b] = ab;
        a = get(a);
        b = get(b);
        if (!type) {
            edges.emplace_back(a, b);
            G2[a].emplace_back(b);
            G2[b].emplace_back(a);
        }
    }
    fill(used2, used2 + DIGITS + ALPHA, false);
    int ans = 1;
    for (int i = 0; i < DIGITS + ALPHA; ++i) {
        int j = get(i);
        if (used2[j])
            continue;
        dfs2(j);
        map<int, int> new_ids;
        for (int j = 0; j < comp.size(); ++j) {
            new_ids[comp[j]] = j;
        }
        vector<int> should(comp.size(), -1);
        vector<pair<int, int>> cur_edges;
        for (auto [a, b] : edges) {
            if (new_ids.count(a) && new_ids.count(b))
                cur_edges.emplace_back(new_ids[a], new_ids[b]);
        }
        for (int j = 0; j < DIGITS; ++j) {
            int tmp = get(j);
            if (new_ids.count(tmp))
                should[new_ids[tmp]] = j;
        }
        ans = mul(ans, solve_g(comp.size(), should, cur_edges));
        comp.clear();
        if (ans == 0)
            break;
    }
    for (int i = 0; i < DIGITS + ALPHA; ++i)
        G2[i].clear();
    /*for (auto [type, ab] : eqs) {
        auto [a, b] = ab;
        if (type)
            cout << a << '=' << b << ' ';
        else
            cout << a << '<' << b << ' ';
        cout << '\n';
    }
    cerr << "eqs " << ans << '\n';*/
    return ans;
}

vector<pair<bool, pair<int, int>>> eqs;

int get_id(char c) {
    if ('0' <= c && c <= '9')
        return c - '0';
    return c - 'A' + DIGITS;
}

void add_eq(char a, char b) {
    eqs.emplace_back(true, make_pair(get_id(a), get_id(b)));
}

void add_less(char a, char b) {
    eqs.emplace_back(false, make_pair(get_id(a), get_id(b)));
}

int total_ans = 0;

void go_gen(vector<pair<string, string>>& lines, int i) {
    if (i == lines.size()) {
        total_ans = add(total_ans, solve(eqs));
        return;
    }
    int old_sz = eqs.size();
    for (int j = 0; j < lines[i].first.size(); ++j) {
        add_less(lines[i].first[j], lines[i].second[j]);
        go_gen(lines, i + 1);
        eqs.pop_back();
        add_eq(lines[i].first[j], lines[i].second[j]);
    }
    eqs.resize(old_sz);
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    
    int n;
    cin >> n;
    vector<pair<string, string>> equal;
    vector<pair<string, string>> need_less;
    for (int i = 0; i < n; ++i) {
        string s;
        cin >> s;
        int j = 0;
        while (s[j] != '=' && s[j] != '<' && s[j] != '>')
            ++j;
        string left = s.substr(0, j);
        string right = s.substr(j + 1, s.size() - j - 1);
        while (left.size() < right.size())
            left = '0' + left;
        while (right.size() < left.size())
            right = '0' + right;
        if (s[j] == '=')
            equal.emplace_back(left, right);
        else if (s[j] == '<')
            need_less.emplace_back(left, right);
        else
            need_less.emplace_back(right, left);
    }
    for (auto [a, b] : equal) {
        for (int i = 0; i < a.size(); ++i)
            add_eq(a[i], b[i]);
    }
    go_gen(need_less, 0);
    cout << total_ans << '\n';
    return 0;
}