#include <bits/stdc++.h>
#define rep(i,j,k) for(int i=(j);i<=(k);i++)
#define per(i,j,k) for(int i=(j);i>=(k);i--)
#define uint unsigned int
#define ll long long
#define ull unsigned long long
#define db double
#define ldb long double
#define pii pair<int,int>
#define pll pair<ll,ll>
#define mkp make_pair
#define eb emplace_back
#define SZ(S) (int)S.size()
#define mod 998244353
//#define mod 1000000007
#define inf 0x3f3f3f3f
#define linf 0x3f3f3f3f3f3f3f3f
using namespace std;

template <class T>
void chkmax(T &x,T y){
    if(x < y) x = y;
}

template <class T>
void chkmin(T &x,T y){
    if(x > y) x = y;
}

inline int popcnt(int x){
    return __builtin_popcount(x);
}

inline int ctz(int x){
    return __builtin_ctz(x);
}

template <int P>
class mod_int
{
    using Z = mod_int;

private:
    static int mo(int x) { return x < 0 ? x + P : x; }

public:
    int x;
    int val() const { return x; }
    mod_int() : x(0) {}
    template <class T>
    mod_int(const T &x_) : x(x_ >= 0 && x_ < P ? static_cast<int>(x_) : mo(static_cast<int>(x_ % P))) {}
    bool operator==(const Z &rhs) const { return x == rhs.x; }
    bool operator!=(const Z &rhs) const { return x != rhs.x; }
    Z operator-() const { return Z(x ? P - x : 0); }
    Z pow(long long k) const
    {
        Z res = 1, t = *this;
        while (k)
        {
            if (k & 1)
                res *= t;
            if (k >>= 1)
                t *= t;
        }
        return res;
    }
    Z &operator++()
    {
        x < P - 1 ? ++x : x = 0;
        return *this;
    }
    Z &operator--()
    {
        x ? --x : x = P - 1;
        return *this;
    }
    Z operator++(int)
    {
        Z ret = x;
        x < P - 1 ? ++x : x = 0;
        return ret;
    }
    Z operator--(int)
    {
        Z ret = x;
        x ? --x : x = P - 1;
        return ret;
    }
    Z inv() const { return pow(P - 2); }
    Z &operator+=(const Z &rhs)
    {
        (x += rhs.x) >= P && (x -= P);
        return *this;
    }
    Z &operator-=(const Z &rhs)
    {
        (x -= rhs.x) < 0 && (x += P);
        return *this;
    }
    Z operator-()
    {
        return -x;
    }
    Z &operator*=(const Z &rhs)
    {
        x = 1ULL * x * rhs.x % P;
        return *this;
    }
    Z &operator/=(const Z &rhs) { return *this *= rhs.inv(); }
#define setO(T, o)                                  \
    friend T operator o(const Z &lhs, const Z &rhs) \
    {                                               \
        Z res = lhs;                                \
        return res o## = rhs;                       \
    }
    setO(Z, +) setO(Z, -) setO(Z, *) setO(Z, /)
#undef setO
    
    friend istream& operator>>(istream& is, mod_int& x)
    {
        long long tmp;
        is >> tmp;
        x = tmp;
        return is;
    }
    friend ostream& operator<<(ostream& os, const mod_int& x)
    {
        os << x.val();
        return os;
    }
};

using Z = mod_int<mod>;
Z power(Z p,ll k){
    Z ans = 1;
    while(k){
        if(k % 2 == 1) ans *= p;
        p *= p;
        k /= 2;
    }
    return ans;
}
int n,m,sum;
int a[35],b[35];
Z fact[6005],ifac[6005];
void init(int L){
    fact[0] = 1;
    rep(i,1,L) fact[i] = fact[i - 1] * i;
    ifac[L] = Z(1) / fact[L];
    per(i,L - 1,0) ifac[i] = ifac[i + 1] * (i + 1);
}
Z val[205],P[205],M[35][35];
Z det(){
    Z ans = 1,iv,rr;
    rep(j,1,n){
        int pos = -1;
        rep(i,j,n) if(M[i][j].val()) pos = i;
        if(pos == -1) return 0;
        if(pos != j){
            ans *= -1;
            rep(k,1,n) swap(M[j][k],M[pos][k]);
        }
        iv = Z(1) / M[j][j];
        rep(i,j + 1,n){
            rr = M[i][j] * iv;
            rep(k,1,n) M[i][k] -= rr * M[j][k];
        }
    } 
    rep(i,1,n) ans *= M[i][i];
    return ans;
}
Z dp[15][6005],res[6005],ans[6005];
void add(int d,int p){
    per(i,sum / 2,0){
        dp[d][i + 1] += dp[d][i];
        dp[d][i] *= -p;
    }
}

void cdq(int l,int r,int d){
    if(l == r){
        Z prd = 1;
        rep(i,0,sum / 2) if(i != l) prd *= l - i;
        prd = Z(1) / prd * res[l];
        rep(i,0,sum / 2) ans[i] += dp[d][i] * prd;
        return;
    }
    int mid = (l + r) >> 1;
    rep(i,0,sum / 2) dp[d + 1][i] = dp[d][i];
    rep(i,mid + 1,r) add(d + 1,i);
    cdq(l,mid,d + 1);

    rep(i,0,sum / 2) dp[d + 1][i] = dp[d][i];
    rep(i,l,mid) add(d + 1,i);
    cdq(mid+1,r,d + 1);
}

int main(){
//    freopen("test.in","r",stdin);
    scanf("%d",&n);
    rep(i,1,n) scanf("%d",&a[i]);
    rep(i,1,n) scanf("%d",&b[i]);
    sum = 0;
    rep(i,1,n){
        sum += b[i] - a[i];
        if(a[i] > b[i]){
            printf("0\n");
            return 0;
        }
        chkmax(m,b[i]);
    }
    if(sum % 2){
        printf("0\n");
        return 0;
    }
    init(sum);
    rep(i,1,n){
        rep(j,i + 1,n){
            if((a[i] - a[j]) * (b[i] - b[j]) < 0){
                printf("0\n");
                return 0;
            }
        }
    }

    rep(p,0,sum / 2){
        P[0] = 1;
        rep(i,1,m) P[i] = -P[i - 1] * p;

        rep(i,0,m){
            val[i] = 0;
            rep(j,0,i / 2) val[i] += P[j] * ifac[j] * ifac[i - 2 * j];
        }
        rep(i,1,n){
            rep(j,1,n){
                if(b[j] >= a[i]) M[i][j] = val[b[j] - a[i]];
                else M[i][j] = 0;
            }
        }
        res[p] = det();
    }

    dp[0][0] = 1;
    cdq(0,sum / 2,0);
    Z answer = 0;
    rep(i,0,sum / 2) answer += fact[sum / 2] * ifac[sum / 2 - i] * fact[sum - 2 * i] * ans[i];
    answer /= power(2,sum / 2);
    printf("%d\n",answer.val());
    return 0;
}