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 <bits/stdc++.h>

using namespace std;

namespace {

    typedef double real;
    typedef long long ll;

    template<class T> ostream& operator<<(ostream& os, const vector<T>& vs) {
        if (vs.empty()) return os << "[]";
        os << "[" << vs[0];
        for (int i = 1; i < vs.size(); i++) os << " " << vs[i];
        return os << "]";
    }
    template<class T> istream& operator>>(istream& is, vector<T>& vs) {
        for (auto it = vs.begin(); it != vs.end(); it++) is >> *it;
        return is;
    }

    const ll MOD = ll(1e9 + 7);

    int N, L;
    vector<int> X, A;
    void input() {
        cin >> N >> L;
        X.clear(); X.resize(N); cin >> X;
        A.clear(); A.resize(N); cin >> A;
    }

    void solve() {
        auto dp = vector< vector<ll> >(2, vector<ll>(L, 0));
        auto sum = vector< vector<ll> >(2, vector<ll>(L + 1, 0));
        for (ll i = 0; i <= L - 1; i++) {
            const ll x = X[0];
            const ll a = A[0];
            if (a == 0) {
                if (i == x) {
                    dp[0][i] = 1;
                }
            } else if (i - x >= 0 && (i - x) % a == 0) {
                dp[0][i] = 1;
            }
            sum[0][i + 1] = (sum[0][i] + dp[0][i]) % MOD;
        }
        for (int i = 1; i <= N - 1; i++) {
            swap(dp[0], dp[1]); fill(dp[0].begin(), dp[0].end(), 0);
            swap(sum[0], sum[1]); fill(sum[0].begin(), sum[0].end(), 0);
            const ll x = X[i];
            const ll a = A[i];
            for (ll j = 0; j <= L - 1; j++) {
                if (a == 0) {
                    if (j == x) {
                        dp[0][j] = sum[1][j];
                    }
                } else if (j - x >= 0 && (j - x) % a == 0) {
                    assert(j - 1 >= 0);
                    dp[0][j] = sum[1][j];
                }
                sum[0][j + 1] = (sum[0][j] + dp[0][j]) % MOD;
            }
        }
        //cout << sum << endl;
        cout << sum[0][L] << endl;
    }
}

int main() {
    input(); solve();
    return 0;
}