Problem:
Score : 1600 points

Problem Statement

Snuke found a random number generator.
It generates an integer between 0 and N-1 (inclusive).
An integer sequence A_0, A_1, \cdots, A_{N-1} represents the probability that each of these integers is generated. The integer i (0 \leq i \leq N-1) is generated with probability A_i / S, where S = \sum_{i=0}^{N-1} A_i. The process of generating an integer is done independently each time the generator is executed.

Now, Snuke will repeatedly generate an integer with this generator until the following condition is satisfied:

For every i (0 \leq i \leq N-1), the integer i has been generated at least B_i times so far.

Find the expected number of times Snuke will generate an integer, and print it modulo 998244353.
More formally, represent the expected number of generations as an irreducible fraction P/Q. Then, there exists a unique integer R such that R \times Q \equiv P \pmod{998244353},\ 0 \leq R < 998244353, so print this R.

From the constraints of this problem, we can prove that the expected number of generations is a finite rational number, and its integer representation modulo 998244353 can be defined.

Constraints

1 \leq N \leq 400

1 \leq A_i

\sum_{i=0}^{N-1} A_i \leq 400

1 \leq B_i

\sum_{i=0}^{N-1} B_i \leq 400

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N
A_0 B_0
A_1 B_1
\vdots
A_{N-1} B_{N-1}

Output

Print the expected number of times Snuke will generate an integer, modulo 998244353.

Sample Input 1

2
1 1
1 1

Sample Output 1

3

The expected number of times Snuke will generate an integer is 3.

Sample Input 2

3
1 3
2 2
3 1

Sample Output 2

971485877

The expected number of times Snuke will generate an integer is 132929/7200.

Sample Input 3

15
29 3
78 69
19 15
82 14
9 120
14 51
3 7
6 14
28 4
13 12
1 5
32 30
49 24
35 23
2 9

Sample Output 3

371626143

Solution in C++14 (GCC 5.4.1) (judge verdict: Runtime Error)

#include <bits/stdc++.h>

using namespace std;

namespace jumpmelon
{
	typedef long long big;

	const int P = 998244353;

	vector<int> operator*(const vector<int> &A, const vector<int> &B)
	{
		int n = (int)A.size(), m = (int)B.size();
		vector<int> R(n + m - 1);
		for (int i = 0; i < n; i++)
			for (int j = 0; j < m; j++)
				R[i + j] = int((R[i + j] + (big)A[i] * B[j]) % P);
		return R;
	}

	vector<int> operator+(const vector<int> &A, const vector<int> &B)
	{
		int n = (int)A.size(), m = (int)B.size();
		vector<int> R(max(n, m));
		for (int i = 0; i < n; i++)
			R[i] = A[i];
		for (int i = 0; i < m; i++)
			R[i] = (R[i] + B[i]) % P;
		return R;
	}

	int inv(int x) { return x == 1 ? 1 : int(big(P - P / x) * inv(P % x) % P); }

	const int MAXN = 400;
	int A[MAXN], B[MAXN];
	int Fac[MAXN + 1], InvFac[MAXN + 1];
	int S[MAXN + 1][MAXN + 1];
	int L[MAXN + 1];
	vector<int> G[MAXN + 1];

	int C(int n, int m) { return int((big)Fac[n] * InvFac[m] % P * InvFac[n - m] % P); }

	void work()
	{
		int n, s = 0;
		scanf("%d", &n);
		for (int i = 0; i < n; i++)
		{
			scanf("%d%d", &A[i], &B[i]);
			s += A[i];
		}
		Fac[0] = 1;
		for (int i = 1; i <= MAXN; i++)
			Fac[i] = int((big)Fac[i - 1] * i % P);
		InvFac[MAXN] = inv(Fac[MAXN]);
		for (int i = MAXN; i >= 1; i--)
			InvFac[i - 1] = int((big)InvFac[i] * i % P);
		G[0] = {1};
		int inv_s = inv(s);
		for (int i = 0, t = 0; i < n; i++)
		{
			int c = int((big)A[i] * inv_s % P);
			vector<int> V(B[i]);
			for (int j = 0, v = 1; j < B[i]; j++, v = int((big)v * c % P))
				V[j] = int(big(P - v) * InvFac[j] % P);
			t += A[i];
			for (int j = t; j >= 0; j--)
			{
				if (!G[j].empty())
					G[j] = G[j] * V;
				if (j >= A[i])
					G[j] = G[j] + G[j - A[i]];
			}
		}
		S[0][0] = 1;
		for (int i = 1; i <= MAXN; i++)
			for (int j = 1; j <= i; j++)
				S[i][j] = int((S[i - 1][j - 1] + big(i - 1) * S[i - 1][j]) % P);
		int ans = 0;
		for (int k = 0; k < (int)G[0].size(); k++)
			ans = int((ans + (big)G[0][k] * Fac[k]) % P);
		for (int d = 1; d < s; d++)
		{
			int c = int((big)d * inv_s % P), inv_c = inv(c);
			int vr = inv((1 + P - c) % P), vv = int((big)c * vr % P);
			L[0] = vr;
			for (int i = 1; i < (int)G[d].size(); i++)
			{
				L[i] = 0;
				for (int j = 0; j < i; j++)
					L[i] = int((L[i] + (big)vv * C(i, j) % P * L[j]) % P);
			}
			for (int k = 0, v = 1; k < (int)G[d].size(); k++, v = int((big)v * inv_c % P))
				for (int i = k, u = 1; i >= 0; i--, u = P - u)
					ans = int(
						(ans + (big)G[d][k] * v % P * S[k][i] % P * u % P * L[i]) % P);
		}
		printf("%d\n", (P - ans) % P);
	}
}

int main()
{
#ifndef ONLINE_JUDGE
	freopen("agc038_e.in", "r", stdin);
	freopen("agc038_e.out", "w", stdout);
#endif
	jumpmelon::work();
	return 0;
}