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 <algorithm>
#include <array>
#include <complex>
#include <cassert>
#include <cctype>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <memory>
#include <queue>
#include <set>
#include <string>
#include <tuple>
#include <vector>

using namespace std;

typedef long long ll;
typedef unsigned long long ull;

int N, L;
int xx[5000];
int x[5000];
int a[5000];
const ll M = 1000000007LL;
ll sum[5001];
ll dp[5000];

int main() {
  cin >> N >> L;
  for(int i = 0; i < N; ++i) {
    cin >> x[i];
    xx[i] = x[i];
  }
  for(int i = 0; i < N; ++i) {
    cin >> a[i];
  }
  int pre = L;
  for(int i = N - 1; i >= 0; --i) {
    if(a[i] != 0){
      int r = (pre - 1 - x[i]) / a[i];
      x[i] += a[i] * r;
    }
    pre = x[i];
  }

  memset(dp, 0, sizeof(dp));
  for(int i = 0; x[0] - a[0] * i >= xx[0]; ++i) {
    dp[x[0] - a[0] * i] = 1;
    if(a[0] == 0) break;
  }
  for(int i = 1; i < N; ++i) {
    sum[0] = 0;
    for(int j = 1; j <= x[i]; ++j) {
      sum[j] = (sum[j - 1] + dp[j-1]) % M;
    }
    memset(dp, 0, sizeof(dp));
    for(int j = 0; x[i] - a[i] * j >= xx[i]; ++j){
      int id = x[i] - a[i] * j;
      dp[id] = sum[id];
      if(a[i] == 0) break;
    }
  }
  ll ans = 0;
  for(int i = 0; i < L; ++i) {
    ans = (ans + dp[i]) % M;
  }
  cout << ans << endl;
}