#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int INF = 1e9 + 10;
const ll INFL = 4e18;

template <ll MOD>
struct ModInt {
    ll value;
    ModInt(ll x = 0) { value = (x >= 0 ? x % MOD : MOD - (-x) % MOD); }
    ModInt operator-() const { return ModInt(-value); }
    ModInt operator+() const { return ModInt(*this); }
    ModInt& operator+=(const ModInt& other) {
        value += other.value;
        if (value >= MOD) value -= MOD;
        return *this;
    }
    ModInt& operator-=(const ModInt& other) {
        value += MOD - other.value;
        if (value >= MOD) value -= MOD;
        return *this;
    }
    ModInt& operator*=(const ModInt other) {
        value = value * other.value % MOD;
        return *this;
    }
    ModInt& operator/=(ModInt other) {
        (*this) *= other.inv();
        return *this;
    }
    ModInt operator+(const ModInt& other) const { return ModInt(*this) += other; }
    ModInt operator-(const ModInt& other) const { return ModInt(*this) -= other; }
    ModInt operator*(const ModInt& other) const { return ModInt(*this) *= other; }
    ModInt operator/(const ModInt& other) const { return ModInt(*this) /= other; }
    ModInt pow(ll x) const {
        ModInt ret(1), mul(value);
        while (x) {
            if (x & 1) ret *= mul;
            mul *= mul;
            x >>= 1;
        }
        return ret;
    }
    ModInt inv() const { return pow(MOD - 2); }
    bool operator==(const ModInt& other) const { return value == other.value; }
    bool operator!=(const ModInt& other) const { return value != other.value; }
    friend ostream& operator<<(ostream& os, const ModInt& x) { return os << x.value; }
    friend istream& operator>>(istream& is, ModInt& x) {
        ll v;
        is >> v;
        x = ModInt<MOD>(v);
        return is;
    }
    static constexpr ll get_mod() { return MOD; }
};
using Mod998 = ModInt<998244353>;
using Mod107 = ModInt<1000000007>;

template <typename T>
struct Combinatorics {
    Combinatorics(int n) {
        fac = vector<T>(n + 1);
        finv = vector<T>(n + 1);
        fac[0] = 1;
        for (int i = 1; i <= n; i++) fac[i] = fac[i - 1] * i;
        finv[n] = fac[n].inv();
        for (int i = n; i >= 1; i--) finv[i - 1] = finv[i] * i;
    }
    T comb(ll n, ll r) {
        if (n < 0 || r < 0 || n - r < 0) return 0;
        return fac[n] * finv[r] * finv[n - r];
    }
    T perm(ll n, ll r) {
        if (n < 0 || r < 0 || n - r < 0) return 0;
        return fac[n] * finv[n - r];
    }
    T fact(int n) { return fac[n]; }
    T factinv(int n) { return finv[n]; }
    T operator()(ll n, ll r) { return comb(n, r); }

private:
    vector<T> fac, finv;
};

using mint = Mod998;

int main() {
    int K;
    cin >> K;
    vector<int> L(K), M(K);
    int N = 0;
    for (int i = 0; i < K; i++) {
        cin >> L[i] >> M[i];
        N += L[i] * M[i];
    }

    Combinatorics<mint> C(N + 10);

    mint ans = C.fact(N);
    for (int i = 0; i < K; i++) ans *= C.factinv(L[i] * M[i]);

    for (int i = 0; i < K; i++) {
        int base = L[i];
        mint res = 1;
        for (int t = 0; t < M[i] - 1; t++) {
            int add = L[i] - 1;
            base += add;
            res *= C(base, add);
            base++;
        }
        ans *= res;
    }

    cout << ans << endl;
}