This is the easy version of the problem. The only difference is that in this version q = 1. You can make hacks only if both versions of the problem are solved.

There is a process that takes place on arrays a and b of length n and length n-1 respectively. 

The process is an infinite sequence of operations. Each operation is as follows: 

  * First, choose a random integer i (1 ≤ i ≤ n-1). 
  * Then, simultaneously set a_i = min\left(a_i, \frac{a_i+a_{i+1}-b_i}{2}\right) and a_{i+1} = max\left(a_{i+1}, \frac{a_i+a_{i+1}+b_i}{2}\right) without any rounding (so values may become non-integer). 

See notes for an example of an operation.

It can be proven that array a converges, i. e. for each i there exists a limit a_i converges to. Let function F(a, b) return the value a_1 converges to after a process on a and b.

You are given array b, but not array a. However, you are given a third array c. Array a is good if it contains only integers and satisfies 0 ≤ a_i ≤ c_i for 1 ≤ i ≤ n.

Your task is to count the number of good arrays a where F(a, b) ≥ x for q values of x. Since the number of arrays can be very large, print it modulo 10^9+7.

Input

The first line contains a single integer n (2 ≤ n ≤ 100).

The second line contains n integers c_1, c_2 …, c_n (0 ≤ c_i ≤ 100).

The third line contains n-1 integers b_1, b_2, …, b_{n-1} (0 ≤ b_i ≤ 100).

The fourth line contains a single integer q (q=1).

The fifth line contains q space separated integers x_1, x_2, …, x_q (-10^5 ≤ x_i ≤ 10^5).

Output

Output q integers, where the i-th integer is the answer to the i-th query, i. e. the number of good arrays a where F(a, b) ≥ x_i modulo 10^9+7.

Example

Input


3
2 3 4
2 1
1
-1


Output


56

Note

The following explanation assumes b = [2, 1] and c=[2, 3, 4] (as in the sample).

Examples of arrays a that are not good: 

  * a = [3, 2, 3] is not good because a_1 > c_1; 
  * a = [0, -1, 3] is not good because a_2 < 0. 



One possible good array a is [0, 2, 4]. We can show that no operation has any effect on this array, so F(a, b) = a_1 = 0.

Another possible good array a is [0, 1, 4]. In a single operation with i = 1, we set a_1 = min((0+1-2)/(2), 0) and a_2 = max((0+1+2)/(2), 1). So, after a single operation with i = 1, a becomes equal to [-1/2, 3/2, 4]. We can show that no operation has any effect on this array, so F(a, b) = -1/2.
#include <cstdio>
#include <algorithm>
const int N=205, MOD=1000000007;
inline int mval(int x) { return x>=MOD?x-MOD:x; }
inline int fix(int x) { return x+(x>>31&MOD); }
inline void inc(int &x, int a) { x=mval(x+a); }
inline void dec(int &x, int a) { x=fix(x-a); }

int n, q, c[N], b[N], f[N][N*N], lim[N], ans[N], prod=1, lw, up;
int main()
{
	scanf("%d", &n);
	for(int i=1; i<=n; ++i) scanf("%d", c+i), up=std::max(up, c[i]), prod=1ll*prod*(c[i]+1)%MOD;
	for(int i=2; i<=n; ++i) scanf("%d", b+i), b[i]+=b[i-1], lw+=b[i]-c[i];
	lw-=c[1];
	lw=-((lw+n-1)/n);
	++lw;
	++up;
	for(int x=lw; x>lw-up; --x)
	{
		f[0][0]=1;
		int sum=0;
		for(int i=1; i<=n; ++i)
		{
			int l=-b[i]-x, r=l+c[i];
			lim[i]=std::max(0, lim[i-1]+l);
			if(sum+r<0) { goto out; }
			std::fill(f[i], f[i]+sum+r-lim[i]+1, 0);
			for(int j=std::max(lim[i-1], -r); j<=sum; ++j)
			{
				inc(f[i][std::max(0, j+l-lim[i])], f[i-1][j-lim[i-1]]);
				dec(f[i][j+r+1-lim[i]], f[i-1][j-lim[i-1]]);
			}
			sum+=r;
			for(int j=1; j<=sum-lim[i]+1; ++j) inc(f[i][j], f[i][j-1]);
		}
		for(int j=0; j<=sum-lim[n]; ++j) inc(ans[lw-x], f[n][j]);
		out:;
	}
	scanf("%d", &q);
	for(int i=1, x; i<=q; ++i)
	{
		scanf("%d", &x);
		printf("%d\n", (x>lw?0:x<=lw-up?prod:ans[lw-x]));
	}
	return 0;
}