package main

import (
	"bufio"
	"fmt"
	"os"
	"sort"
)

const M = 1000000007

func readInt(r *bufio.Reader) int64 {
	var n int64
	var sign int64 = 1
	var c byte
	var err error
	for {
		c, err = r.ReadByte()
		if err != nil {
			return 0
		}
		if c == '-' {
			sign = -1
			continue
		}
		if c >= '0' && c <= '9' {
			n = int64(c - '0')
			break
		}
	}
	for {
		c, err = r.ReadByte()
		if err != nil || c < '0' || c > '9' {
			break
		}
		n = n*10 + int64(c-'0')
	}
	return n * sign
}

func main() {
	reader := bufio.NewReader(os.Stdin)
	writer := bufio.NewWriter(os.Stdout)
	defer writer.Flush()

	n := int(readInt(reader))
	q := int(readInt(reader))

	a := make([]int64, n+1)
	for i := 1; i <= n; i++ {
		a[i] = readInt(reader)
	}

	b := make([]int64, n+1)
	S := make([]int64, n+1)
	for i := 1; i <= n; i++ {
		b[i] = readInt(reader)
		S[i] = S[i-1] + b[i]
	}

	D := make([]int64, n)
	for i := 1; i < n; i++ {
		D[i] = a[i+1] - a[i]
	}

	prefD := make([]int64, n)
	prefSD := make([]int64, n)
	for i := 1; i < n; i++ {
		prefD[i] = (prefD[i-1] + D[i]) % M

		sMod := (S[i]%M + M) % M
		dMod := D[i] % M
		sd := (sMod * dMod) % M
		prefSD[i] = (prefSD[i-1] + sd) % M
	}

	type Query struct {
		l, r, id int
		x        int64
	}

	queries := make([]Query, q)
	for i := 0; i < q; i++ {
		l := int(readInt(reader))
		r := int(readInt(reader))
		queries[i] = Query{l, r, i, S[l-1]}
	}

	ans := make([]int64, q)

	sort.Slice(queries, func(i, j int) bool {
		return queries[i].x < queries[j].x
	})

	type Point struct {
		s int64
		k int
		d int64
	}

	points := make([]Point, n-1)
	for i := 1; i < n; i++ {
		points[i-1] = Point{S[i], i, D[i]}
	}

	sort.Slice(points, func(i, j int) bool {
		return points[i].s < points[j].s
	})

	bitD := make([]int64, n+1)
	bitSD := make([]int64, n+1)

	add := func(bit []int64, idx int, val int64) {
		val = (val%M + M) % M
		for i := idx; i <= n; i += i & -i {
			bit[i] = (bit[i] + val) % M
		}
	}

	query := func(bit []int64, idx int) int64 {
		res := int64(0)
		for i := idx; i > 0; i -= i & -i {
			res = (res + bit[i]) % M
		}
		return res
	}

	ptIdx := 0
	for _, qu := range queries {
		if qu.l == qu.r {
			ans[qu.id] = 0
			continue
		}

		for ptIdx < len(points) && points[ptIdx].s < qu.x {
			p := points[ptIdx]
			add(bitD, p.k, p.d)
			sMod := (p.s%M + M) % M
			dMod := p.d % M
			add(bitSD, p.k, sMod*dMod)
			ptIdx++
		}

		l, r := qu.l, qu.r-1

		sumD_less := (query(bitD, r) - query(bitD, l-1) + M) % M
		sumSD_less := (query(bitSD, r) - query(bitSD, l-1) + M) % M

		sumD_all := (prefD[r] - prefD[l-1] + M) % M
		sumSD_all := (prefSD[r] - prefSD[l-1] + M) % M

		sumD_greater := (sumD_all - sumD_less + M) % M
		sumSD_greater := (sumSD_all - sumSD_less + M) % M

		xMod := (qu.x%M + M) % M

		res := (xMod * sumD_less) % M
		res = (res - sumSD_less + M) % M
		res = (res + sumSD_greater) % M
		res = (res - xMod*sumD_greater%M + M) % M

		ans[qu.id] = res
	}

	for i := 0; i < q; i++ {
		fmt.Fprintln(writer, ans[i])
	}
}