#pragma GCC optimize("Ofast")
#include <iostream>
#include <vector>
#include <algorithm>
#include <map>
#include <queue>
#include <cstdio>
#include <ctime>
#include <assert.h>
#include <chrono>
#include <random>
#include <numeric>
#include <set>
#include <deque>
#include <stack>
#include <sstream>
#include <utility>
#include <cstring>
#include <unordered_map>
#include <unordered_set>
#include <tuple>
#include <array>
#include <bitset>
using namespace std;
typedef long long int ll;
typedef unsigned long long ull;

mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
ll myRand(ll B) {
    return (ull)rng() % B;
}
inline double time() {
    return static_cast<long double>(chrono::duration_cast<chrono::nanoseconds>(chrono::steady_clock::now().time_since_epoch()).count()) * 1e-9;
}

constexpr ll mod = 998244353;
constexpr ll inv = 499122177;

// 右上がりの等差数列を考える
ll solve(vector<ll> L,vector<ll> R){
    int n = L.size();
    ll res = 0;
    vector<pair<ll,ll>> Lv(n),Rv(n);
    {
        // 下限を求めている
        vector<int> v;
        for(ll i=0;i<n;i++){
            while(v.size()){
                ll j = v.back();
                if(R[j]-Rv[j].first*j >= R[i]-Rv[j].first*i){
                    v.pop_back();
                }
                else break;
            }
            ll ok = 1;
            if(v.size()){
                ll j = v.back();
                // L[j]-j*d >= L[i]-i*d
                // を満たす最小のd
                // L[j]-L[i] >= (j-i)*d
                // L[i]-L[j] <= (i-j)*d
                // (L[i]-L[j])/(i-j) <= d
                ok = (R[i]-R[j])/(i-j);
                if((L[i]-L[j]) > (i-j)*ok) ok++;
            }
            v.push_back(i);
            Rv[i].first = ok;
        }
    }
    {
        // 上限を求めている
        vector<int> v;
        for(ll i=n-1;i>=0;i--){
            while(v.size()){
                ll j = v.back();
                if(R[j]-Rv[j].second*j >= R[i]-Rv[j].second*i){
                    v.pop_back();
                }
                else break;
            }
            ll ok = 1e12;
            if(v.size()){
                ll j = v.back();
                // L[j]-j*d >= L[i]-i*d
                // を満たす最大のd
                // L[j]-L[i] >= (j-i)*d
                // (L[j]-L[i])/(j-i) >= d
                ok = (R[j]-R[i])/(j-i);
            }
            v.push_back(i);
            Rv[i].second = ok;
        }
    }
    {
        // 上限を求めている
        vector<int> v;
        for(ll i=0;i<n;i++){
            while(v.size()){
                ll j = v.back();
                if(L[j]-Lv[j].second*j <= L[i]-Lv[j].second*i){
                    v.pop_back();
                }
                else break;
            }
            ll ok = 1e12;
            if(v.size()){
                ll j = v.back();
                // L[j]-j*d <= L[i]-i*d
                // を満たす最大のd
                // L[j]-L[i] <= (j-i)*d
                // L[i]-L[j] >= (i-j)*d
                // (L[i]-L[j])/(i-j) >= d
                ok = (L[i]-L[j])/(i-j);
            }
            v.push_back(i);
            Lv[i].second = ok;
        }
        {
            // 下限を求めている
            vector<int> v;
            for(ll i=n-1;i>=0;i--){
                while(v.size()){
                    ll j = v.back();
                    if(L[j]-Lv[j].first*j <= L[i]-Lv[j].first*i){
                        v.pop_back();
                    }
                    else break;
                }
                ll ok = 1;
                if(v.size()){
                    ll j = v.back();
                    // L[j]-j*d <= L[i]-i*d
                    // を満たす最小のd
                    // L[j]-L[i] <= (j-i)*d
                    // (L[j]-L[i])/(j-i) <= d
                    ok = (L[j]-L[i])/(j-i);
                    while(L[j]-(ok)*j > L[i]-(ok)*i){
                        ok++;
                    }
                }
                v.push_back(i);
                Lv[i].first = ok;
            }
        }
    }
    vector<pair<pair<ll,ll>,int>> Larray;
    {
        vector<pair<pair<ll,ll>,int>> v;
        for(int i=0;i<n;i++){
            if(Lv[i].first <= Lv[i].second){
                v.push_back({Lv[i],i});
            }
        }
        sort(v.begin(), v.end());
        ll cur = 1;
        for(auto p:v){
            if(cur <= p.first.second){
                Larray.push_back({{cur,p.first.second},p.second});
                cur = p.first.second+1;
            }
        }
    }
    vector<pair<pair<ll,ll>,int>> Rarray;
    {
        vector<pair<pair<ll,ll>,int>> v;
        for(int i=0;i<n;i++){
            if(Rv[i].first <= Rv[i].second){
                v.push_back({Rv[i],i});
            }
        }
        sort(v.begin(), v.end());
        ll cur = 1;
        for(auto p:v){
            if(cur <= p.first.second){
                Rarray.push_back({{cur,p.first.second},p.second});
                cur = p.first.second+1;
            }
        }
    }
    int i = 0, j = 0;
    ll mi = 1;
    while(i < Larray.size() and j < Rarray.size()){
        ll mx = min(Larray[i].first.second, Rarray[j].first.second);
        // mi <= d <= mx の範囲で考える
        ll Lidx = Larray[i].second;
        ll Ridx = Rarray[j].second;
        ll ok = mi-1, ng = mx+1;
        while(ng-ok > 1){
            ll mid = (ng+ok)/2;
            if(R[Ridx]-Ridx*mid >= L[Lidx]-Lidx*mid){
                ok = mid;
            }
            else{
                ng = mid;
            }
        }
        if(mi <= ok){
            // mi <= d <= ok の範囲で考える
            res += ((R[Ridx]-L[Lidx]+1)%mod)*((ok-mi+1)%mod)%mod;
            ll ad = (mi+ok)%mod*((ok-mi+1)%mod)%mod*inv%mod;
            ad *= (-Ridx+Lidx)%mod;
            ad %= mod;
            res += ad;
        }
        if(Larray[i].first.second == mx) i++;
        if(Rarray[j].first.second == mx) j++;
        mi = mx+1;
    }
    res %= mod;
    if(res < 0) res += mod;
    return res;
}

int main(){
    cin.tie(nullptr);
    ios::sync_with_stdio(false);
    int n; cin >> n;
    vector<ll> L(n),R(n);
    ll mxL = 0;
    for(int i=0;i<n;i++){
        cin >> L[i];
        mxL = max(mxL, L[i]);
    }
    ll miR = 1e18;
    for(int i=0;i<n;i++){
        cin >> R[i];
        miR = min(miR, R[i]);
    }
    if(n == 2){
        cout << ((R[0]-L[0]+1)%mod) * ((R[1]-L[1]+1)%mod) % mod << endl;
        return 0;
    }
    // [mxL,miR]の定数数列は作れる
    ll res = 0;
    if(mxL <= miR){
        res += miR-mxL+1;
        res %= mod;
    }
    res += solve(L,R);
    reverse(L.begin(), L.end());
    reverse(R.begin(), R.end());
    res += solve(L,R);
    cout << res%mod << endl;
}