#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define pii pair<int,int>
#define fi first
#define se second
#define mkp make_pair
const int N=35,M=205,mo=998244353;
int n,m;
pii ps[N];
int frac[N*M],inv[N*M];
int rev[N*M];
int add(int x,int y){ x+=y;return x>=mo?x-mo:x;}
int mi(int x,int y) {
	int res=1;
	for(;y;y>>=1,x=(ll)x*x%mo)
		if(y&1) res=(ll)res*x%mo;
	return res;
}
void init()
{
	frac[0]=1;
	for(int i=1;i<N*M;i++) frac[i]=(ll)frac[i-1]*i%mo;
	inv[N*M-1]=mi(frac[N*M-1],mo-2);
	for(int i=N*M-2;i>=0;--i) inv[i]=(ll)inv[i+1]*(i+1)%mo;
}
int nn,lg;
void init_p(int len)
{
	nn=1,lg=0;
	while(nn<len) nn<<=1,lg++;
	rev[0]=0;
	for(int i=0;i<nn;i++) rev[i]=(rev[i>>1]>>1)|((i&1)<<(lg-1));
}
void NTT(vector<int> &f,int tp) {
	int i,j,k,len,w,wn;
	for(i=0;i<nn;i++) 
		if(rev[i]>i) swap(f[i],f[rev[i]]);
	for(len=1;len<nn;len<<=1)
	{
		wn=mi((tp?(mo+1)/3:3),(mo-1)/(len<<1));
		for(i=0;i<nn;i+=(len<<1)) 
			for(j=0,w=1;j<len;j++,w=(ll)w*wn%mo) {
				k=(ll)f[i|j|len]*w%mo;
				f[i|j|len]=add(f[i|j],mo-k);
				f[i|j]=add(f[i|j],k);
			}
	}
	if(!tp) return;
	j=mi(nn,mo-2);
	for(i=0;i<nn;i++) f[i]=(ll)f[i]*j%mo;
}

vector<int> a[N][N],gr;

int mat[N][N];
int gauss()
{
	int i,j,k;
	int sth,ans=1,tv;
	
	for(i=sth=1;i<=n;i++) 
	{
		for(k=sth,j=sth;j<=n;j++) 
			if(mat[j][i]) { k=j;break;}
		if(!mat[k][i]) continue;
		if(k!=sth) {
			ans=mo-ans;
			swap(mat[sth],mat[k]);
		}
		++sth;
		for(j=sth;j<=n;j++) {
			if(!mat[j][i]) continue;
			tv=(ll)mat[j][i]*mi(mat[sth-1][i],mo-2)%mo;
			for(k=i;k<=n;k++) 
				mat[j][k]=add(mat[j][k],mo-(ll)mat[sth-1][k]*tv%mo);
		}
	}
	for(i=1;i<=n;i++) ans=(ll)ans*mat[i][i]%mo;
	return ans;
}

int main()
{
	scanf("%d",&n);
	int i,j,k;
	init();
	for(i=1;i<=n;i++) scanf("%d",&ps[i].fi);
	for(i=1;i<=n;i++) scanf("%d",&ps[i].se);
	sort(ps+1,ps+1+n);
	int mx=0,cnt=0,mxd=0;
	for(i=1;i<=n;i++) {
		if(mx>=ps[i].se||ps[i].se>ps[i].se) return puts("0"),0;
		m+=ps[i].se-ps[i].fi;
		mx=max(mx,ps[i].se);
		mxd=max(mxd,ps[i].se-ps[i].fi);
		cnt+=ps[i].se-ps[i].fi;
	}
	m=(m/2)+1;
	if((cnt&1)||mxd>cnt/2) return puts("0"),0;
	
	int d;
	init_p(m);
	for(i=1;i<=n;i++) {
		for(j=1;j<=n;j++) {
			a[i][j].resize(nn,0);
			d=ps[j].se-ps[i].fi;
			for(k=0;k<=d/2;k++) 
				a[i][j][k]=(ll)inv[k]*inv[d-2*k]%mo*
								((k&1)?mo-1:1)%mo;
			NTT(a[i][j],0);
		}
	}
	for(d=0,i=1;i<=n;i++) d+=ps[i].se-ps[i].fi;
	d/=2;
	gr.resize(nn,0);
	for(k=0;k<nn;k++) {
		for(i=1;i<=n;i++) 
			for(j=1;j<=n;j++) 
				mat[i][j]=a[i][j][k];
		// cout<<"gauss:"<<k<<endl;
		// for(i=1;i<=n;i++) {
			// for(j=1;j<=n;j++) cout<<mat[i][j]<<" ";
			// puts("");
		// }
		gr[k]=gauss();
	}
	NTT(gr,1);
	int ans=0;
	for(i=0;i<m;i++) 
		ans=add(ans,(ll)gr[i]*
			frac[d]%mo*inv[d-i]%mo*
			frac[2*d-2*i]%mo);
	ans=(ll)ans*mi(mi(2,d),mo-2)%mo;// 一次操作之间没有先后顺序
	printf("%d\n",ans);
	return 0;
}
/*
给定 a[1~n] 和对应的 b[1~n]
每次选择 a[i],a[j] ,i!=j ，令 a[i]++,a[j]++
要求任意时刻 a 不能存在相同的数，问操作使得 a -> b 的方案数
对 a 排序，对应的 b 也应当升序，否则必定有交
总操作次数 sigma(b[i]-a[i]) 应为偶数，且需要操作最多的位置不应超过其余之和
考虑 a 不能相同的限制，这可视作 a->b 的不交格路计数
于是强行套 LGV 的形式 (实际上应当可用若干超平面反射容斥得到该形式)
现在问题变成计算 sigma(w){ pro(val(a[i]->b[w[i]])) * sgn(w) }， w 为排列
先考虑对于确定的 w 计算答案
一次操作选择的两个位置不能相同，不妨容斥，钦定有 c[i] 次操作两个位置都是 i
记 d[i]=b[w[i]]-a[i], D = sigma(d[i])
sigma( (-1)^sigma(c[i]) * C( D, {c[i]} ) * C( 2*(D-sigma(c[i])) , { d[i]-2*c[i] } ) )
对于确定的排列能够计算，但枚举排列仍然是不现实的
考虑借用行列式计算时自会枚举排列的特性
注意到计算时，c[i] 之间是独立的，唯一需要关心的是  sigma(c[i])
于是记 F_i(x) = sigma( (-1)^j * 1/j! * 1/(d[i]-2*j)! * x^j )
与 sigma(c[i]) 有关的项可以最后再乘
于是得到多项式矩阵 A，其中 A[i][j] 表示 w[i]=j 时的 F_i(x)
考虑插值，每个位置是 m 次多项式，总共 n 个相乘，带入 n*m 个数即可
对矩阵内的多项式系数转点值，并用单位根插值
最后点值转系数还原即可
*/