package main

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

const MOD int64 = 1000000007

func countArrays(n int, c []int, t []int64, total int, x int64) int64 {
	dp := make([]int64, total+1)
	ndp := make([]int64, total+1)
	pref := make([]int64, total+1)
	dp[0] = 1
	curMax := 0

	for i := 1; i <= n; i++ {
		pref[0] = dp[0]
		for s := 1; s <= curMax; s++ {
			pref[s] = pref[s-1] + dp[s]
			if pref[s] >= MOD {
				pref[s] -= MOD
			}
		}

		newMax := curMax + c[i-1]
		lim := c[i-1]

		for s := 0; s <= newMax; s++ {
			r := s
			if r > curMax {
				r = curMax
			}
			l := s - lim
			if l < 0 {
				l = 0
			}
			if l > r {
				ndp[s] = 0
			} else {
				v := pref[r]
				if l > 0 {
					v -= pref[l-1]
					if v < 0 {
						v += MOD
					}
				}
				ndp[s] = v
			}
		}

		bound64 := int64(i)*x + t[i]
		if bound64 > 0 {
			if bound64 > int64(newMax) {
				for s := 0; s <= newMax; s++ {
					ndp[s] = 0
				}
			} else {
				bound := int(bound64)
				for s := 0; s < bound; s++ {
					ndp[s] = 0
				}
			}
		}

		dp, ndp = ndp, dp
		curMax = newMax
	}

	var ans int64
	for s := 0; s <= curMax; s++ {
		ans += dp[s]
		if ans >= MOD {
			ans -= MOD
		}
	}
	return ans
}

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

	var n int
	fmt.Fscan(in, &n)

	c := make([]int, n)
	total := 0
	for i := 0; i < n; i++ {
		fmt.Fscan(in, &c[i])
		total += c[i]
	}

	b := make([]int, n-1)
	for i := 0; 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])
	}

	t := make([]int64, n+1)
	var prefB, sumP int64
	for i := 1; i <= n; i++ {
		if i > 1 {
			prefB += int64(b[i-2])
		}
		sumP += prefB
		t[i] = sumP
	}

	for i := 0; i < q; i++ {
		if i > 0 {
			fmt.Fprint(out, " ")
		}
		fmt.Fprint(out, countArrays(n, c, t, total, xs[i]))
	}
}