package main

import (
	"bufio"
	"fmt"
	"io"
	"os"
)

const MOD int64 = 1000000007

func modPow(a, e int64) int64 {
	res := int64(1)
	for e > 0 {
		if e&1 == 1 {
			res = res * a % MOD
		}
		a = a * a % MOD
		e >>= 1
	}
	return res
}

func max(a, b int64) int64 {
	if a > b {
		return a
	}
	return b
}

func min(a, b int64) int64 {
	if a < b {
		return a
	}
	return b
}

func overlap2(l1, r1, l2, r2 int64) int64 {
	lo := max(l1, l2)
	hi := min(r1, r2)
	if hi < lo {
		return 0
	}
	return hi - lo + 1
}

func overlap3(l1, r1, l2, r2, l3, r3 int64) int64 {
	lo := max(l1, max(l2, l3))
	hi := min(r1, min(r2, r3))
	if hi < lo {
		return 0
	}
	return hi - lo + 1
}

func main() {
	data, _ := io.ReadAll(os.Stdin)
	idx := 0
	nextInt := func() int64 {
		for idx < len(data) && (data[idx] < '0' || data[idx] > '9') {
			idx++
		}
		var v int64
		for idx < len(data) && data[idx] >= '0' && data[idx] <= '9' {
			v = v*10 + int64(data[idx]-'0')
			idx++
		}
		return v
	}

	n := int(nextInt())
	l := make([]int64, n)
	r := make([]int64, n)
	for i := 0; i < n; i++ {
		l[i] = nextInt()
	}
	for i := 0; i < n; i++ {
		r[i] = nextInt()
	}

	inv := make([]int64, n)
	for i := 0; i < n; i++ {
		length := r[i] - l[i] + 1
		inv[i] = modPow(length, MOD-2)
	}

	m := n - 1
	p := make([]int64, m)

	var sumP, sumSq int64
	for i := 0; i < m; i++ {
		c := overlap2(l[i], r[i], l[i+1], r[i+1])
		eq := c % MOD
		eq = eq * inv[i] % MOD
		eq = eq * inv[i+1] % MOD
		pi := 1 - eq
		if pi < 0 {
			pi += MOD
		}
		p[i] = pi
		sumP += pi
		if sumP >= MOD {
			sumP -= MOD
		}
		sumSq = (sumSq + pi*pi)%MOD
	}

	var adjProd, sumQ int64
	for i := 0; i+1 < m; i++ {
		adjProd += p[i] * p[i+1] % MOD
		if adjProd >= MOD {
			adjProd -= MOD
		}

		d := overlap3(l[i], r[i], l[i+1], r[i+1], l[i+2], r[i+2])
		t := d % MOD
		t = t * inv[i] % MOD
		t = t * inv[i+1] % MOD
		t = t * inv[i+2] % MOD

		q := p[i] + p[i+1] - 1 + t
		q %= MOD
		if q < 0 {
			q += MOD
		}
		sumQ += q
		if sumQ >= MOD {
			sumQ -= MOD
		}
	}

	ans := int64(1)
	ans = (ans + 3*sumP) % MOD
	ans = (ans + sumP*sumP) % MOD
	ans = (ans - sumSq) % MOD
	ans = (ans - 2*adjProd) % MOD
	ans = (ans + 2*sumQ) % MOD
	ans %= MOD
	if ans < 0 {
		ans += MOD
	}

	out := bufio.NewWriterSize(os.Stdout, 1<<20)
	fmt.Fprint(out, ans)
	out.Flush()
}