```go
package main

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

const MOD int = 1000000007

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

	var n int
	if _, err := fmt.Fscan(in, &n); err != nil {
		return
	}
	c := make([]int, n+1)
	for i := 1; i <= n; i++ {
		fmt.Fscan(in, &c[i])
	}
	b := make([]int, n)
	for i := 1; i <= n-1; i++ {
		fmt.Fscan(in, &b[i])
	}
	var q int
	fmt.Fscan(in, &q)
	xs := make([]int64, q)
	for i := 0; i < q; i++ {
		fmt.Fscan(in, &xs[i])
	}

	pb := make([]int64, n)   // prefix sums of b
	for i := 1; i <= n-1; i++ {
		pb[i] = pb[i-1] + int64(b[i])
	}
	spb := make([]int64, n+1) // spb[k] = sum_{u=1..k-1} pb[u]
	for k := 2; k <= n; k++ {
		spb[k] = spb[k-1] + pb[k-1]
	}
	sumCpref := make([]int, n+1)
	for i := 1; i <= n; i++ {
		sumCpref[i] = sumCpref[i-1] + c[i]
	}

	for qi := 0; qi < q; qi++ {
		x := xs[qi]
		allTrivial := true
		impossible := false
		LB := make([]int, n+1)
		for k := 1; k <= n; k++ {
			req := int64(k)*x + spb[k]
			if req > 0 {
				allTrivial = false
			}
			lb := req
			if lb < 0 {
				lb = 0
			}
			if lb > int64(sumCpref[k]) {
				impossible = true
				break
			}
			LB[k] = int(lb)
		}
		if impossible {
			fmt.Fprint(out, 0)
			if qi+1 < q {
				fmt.Fprint(out, " ")
			}
			continue
		}
		if allTrivial {
			ans := 1
			for i := 1; i <= n; i++ {
				ans = ans * (c[i] + 1) % MOD
			}
			fmt.Fprint(out, ans)
			if qi+1 < q {
				fmt.Fprint(out, " ")
			}
			continue
		}

		maxSum := sumCpref[n]
		dp := make([]int, maxSum+1)
		dp[0] = 1
		prevMax := 0
		for i := 1; i <= n; i++ {
			newMax := prevMax + c[i]
			pref := make([]int, prevMax+2)
			for s := 0; s <= prevMax; s++ {
				pref[s+1] = pref[s] + dp[s]
				if pref[s+1] >= MOD {
					pref[s+1] -= MOD
				}
			}
			nextdp := make([]int, newMax+1)
			lb := LB[i]
			if lb < 0 {
				lb = 0
			}
			for s := lb; s <= newMax; s++ {
				lo := s - c[i]
				if lo < 0 {
					lo = 0
				}
				if lo > prevMax {
					continue
				}
				hi := s
				if hi > prevMax {
					hi = prevMax
				}
				val := pref[hi+1] - pref[lo]
				if val < 0 {
					val += MOD
				}
				nextdp[s] = val
			}
			dp = nextdp
			prevMax = newMax
		}
		ans := 0
		for s := 0; s <= prevMax; s++ {
			ans += dp[s]
			if ans >= MOD {
				ans -= MOD
			}
		}
		fmt.Fprint(out, ans)
		if qi+1 < q {
			fmt.Fprint(out, " ")
		}
	}
}
```