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:
/*
 * 2665.cc: Hopping Hearts
 */

#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<iostream>
#include<string>
#include<vector>
#include<map>
#include<set>
#include<stack>
#include<list>
#include<queue>
#include<deque>
#include<algorithm>
#include<numeric>
#include<utility>
#include<complex>
#include<functional>
 
using namespace std;

/* constant */

const int MAX_N = 5000;
const int MAX_L = 5000;

typedef long long ll;
const ll MOD = 1000000007;

/* typedef */

/* global variables */

int xs[MAX_N], as[MAX_N], ts[MAX_N];
ll dp[MAX_N][MAX_L];

/* subroutines */

/* main */

int main() {
  int n, l;
  cin >> n >> l;

  for (int i = 0; i < n; i++) cin >> xs[i];
  for (int i = 0; i < n; i++) cin >> as[i];
  for (int i = 0; i < n; i++)
    ts[i] = (as[i] == 0) ? 0 : (l - 1 - xs[i]) / as[i];
  //for (int i = 0; i < n; i++) printf("%d ", ts[i]); putchar('\n');

  for (int j = 0; j <= ts[0]; j++) dp[0][j] = j + 1;
  for (int i = 1; i < n; i++) {
    for (int j = 0; j <= ts[i]; j++) {
      int k = ts[i - 1];
      if (as[i - 1] > 0)
	k = min(k, ((xs[i] + as[i] * j) - 1 - xs[i - 1]) / as[i - 1]);
      dp[i][j] = (((j > 0) ? dp[i][j - 1] : 0) + dp[i - 1][k]) % MOD;
    }
  }

  printf("%lld\n", dp[n - 1][ts[n - 1]]);
  return 0;
}