Problem: Problem statement

N-winged rabbit is on a balance beam of length L-1. The initial position of the i-th rabbit is the integer x_i, which satisfies 0 ≤ x_ {i} \ lt x_ {i + 1} ≤ L−1. The coordinates increase as you move to the right. Any i-th rabbit can jump to the right (ie, move from x_i to x_i + a_i) any number of times, just a distance a_i. However, you cannot jump over another rabbit or enter a position below -1 or above L. Also, at most one rabbit can jump at the same time, and at most one rabbit can exist at a certain coordinate.

How many possible states of x_ {0},…, x_ {N−1} after starting from the initial state and repeating the jump any number of times? Find by the remainder divided by 1 \, 000 \, 000 \, 007.

input

The input is given in the following format.


N L
x_ {0}… x_ {N−1}
a_ {0}… a_ {N−1}


Constraint

* All inputs are integers
* 1 \ ≤ N \ ≤ 5 \,000
* N \ ≤ L \ ≤ 5 \,000
* 0 \ ≤ x_ {i} \ lt x_ {i + 1} \ ≤ L−1
* 0 \ ≤ a_ {i} \ ≤ L−1



output

Print the answer in one line.

sample

Sample input 1


13
0
1


Sample output 1


3


If 1/0 is used to express the presence / absence of a rabbit, there are three ways: 100, 010, and 001.

Sample input 2


twenty four
0 1
1 2


Sample output 2


Four


There are four ways: 1100, 1001, 0101, 0011.

Sample input 3


10 50
0 1 2 3 4 5 6 7 8 9
1 1 1 1 1 1 1 1 1 1


Sample output 3


272278100


The binomial coefficient C (50,10) = 10 \, 272 \, 278 \, 170, and the remainder obtained by dividing it by 1 \, 000 \, 000 \, 007 is 272 \, 278 \, 100.





Example

Input

1 3
0
1


Output

3

Solution (in CPP):

Solution:
#include "iostream"
#include "random"
#include "string"
#include "bitset"
#include "algorithm"
#include "map"
#include "queue"
#include "list"
#include "set"
#include "climits"
#include "iomanip"

using namespace std;
using ll = long long int;

const long long int MOD = 1000000007;

int main() {
	cin.tie(0);
	ios::sync_with_stdio(false);

	int N, M;

	cin >> N >> M;
	vector<vector<long long int>>dp(N, vector<long long int>(M));
	vector<int>v(N);
	for (int i = 0; i < N; i++)cin >> v[i];
	vector<int>w(N);
	for (int i = 0; i < N; i++)cin >> w[i];
	if (w[0]) {
		for (int i = v[0]; i < M; i += w[0])dp[0][i] = 1;
	}
	else {
		dp[0][v[0]] = 1;
	}
	for (int i = 1; i < M; i++) {
		dp[0][i] += dp[0][i - 1];
		dp[0][i] %= MOD;
	}
	for (int i = 1; i < N; i++) {
		if (w[i]) {
			for (int j = v[i]; j < M; j += w[i]) {
				if (j)dp[i][j] = dp[i - 1][j - 1];
			}
		}
		else {
			dp[i][v[i]] = dp[i - 1][v[i] - 1];
		}
		for (int j = 1; j < M; j++) {
			dp[i][j] += dp[i][j - 1];
			dp[i][j] %= MOD;
		}
	}
	cout << dp.back().back() << endl;
}