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 JAVA):

Solution:
import java.util.*;
import java.math.*;
import java.awt.geom.*;
import java.io.*;
    
    
public class Main {
	static int INF = 2 << 27;
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int l = sc.nextInt();
		int[] x = new int[n];
		int[] a = new int[n];
		for(int i = 0; i < n; i++) {
			x[i] = sc.nextInt();
		}
		for(int i = 0; i < n; i++) {
			a[i] = sc.nextInt();
		}
		int[][] dp = new int[n+1][l+1];
		BinaryIndexedTree[] bit = new BinaryIndexedTree[n+1];
		for(int i = 0; i < n+1; i++) {
			bit[i] = new BinaryIndexedTree(l+2,l+2);
		}
		bit[n].add(1, 1);
		for(int i = n - 1; i >= 0; i--) {
			for(int j = 0; ; j++) {
				if(a[i] == 0) {
					bit[i].add(l + 1 - x[i], bit[i+1].sum(l + 1 - x[i] + 1) % 1000000007);
					break;
				}
				else {
					if(a[i] * j + x[i] > l) break;
					bit[i].add(l + 1 - (x[i] + a[i] * j), bit[i+1].sum(l + 1 - (x[i] + a[i] * j + 1)) % 1000000007);
				}
			}
		}
		
		System.out.println(bit[0].sum(l+1));
		
		
		
		
	}
	
	
	
}

class BinaryIndexedTree {
	int MAX_N;
	int[] bit = new int[MAX_N+1];
	int n;
	
	BinaryIndexedTree(int MAX_N, int n) {
		this.MAX_N = MAX_N;
		this.bit = new int[MAX_N+1];
		this.n = n;
	}
	
	
	int sum(int i) {
		int s = 0;
		while(i > 0) {
			s += bit[i];
			s %= 1000000007;
			i -= i & -i;
		}
		return s;
	}
	
	void add(int i , int x) {
		while(i <= n) {
			bit[i] += x ;
			bit[i] %= 1000000007;
			i += i & -i;
		}
	}
}