Problem: There is a set consisting of N distinct integers. The i-th smallest element in this set is S_i. We want to divide this set into two sets, X and Y, such that:

* The absolute difference of any two distinct elements in X is A or greater.
* The absolute difference of any two distinct elements in Y is B or greater.



How many ways are there to perform such division, modulo 10^9 + 7? Note that one of X and Y may be empty.

Constraints

* All input values are integers.
* 1 ≦ N ≦ 10^5
* 1 ≦ A , B ≦ 10^{18}
* 0 ≦ S_i ≦ 10^{18}(1 ≦ i ≦ N)
* S_i < S_{i+1}(1 ≦ i ≦ N - 1)

Input

The input is given from Standard Input in the following format:


N A B
S_1
:
S_N


Output

Print the number of the different divisions under the conditions, modulo 10^9 + 7.

Examples

Input

5 3 7
1
3
6
9
12


Output

5


Input

7 5 3
0
2
4
7
8
11
15


Output

4


Input

8 2 9
3
4
5
13
15
22
26
32


Output

13


Input

3 3 4
5
6
7


Output

0

Solution (in CPP):

Solution:
#include <iostream>
#include <cstdio>
#include <cstring>
typedef long long lint;
const int N=1e5+5;
const int mod=1e9+7;
int n,pre_dp[N][2];
lint lim_a,lim_b,val[N];

template <class T> inline T nxi(){
	T x=0;
	char c;
	while((c=getchar())>'9'||c<'0');
	while(x=x*10-48+c,(c=getchar())>='0'&&c<='9');
	return x;
}

inline int get_dp(int l,int r,bool type){
	if(l>r) return 0;
	return (pre_dp[r][type]-(l>0?pre_dp[l-1][type]:0)+mod)%mod;
}

int main(){
	n=nxi<int>();
	lim_a=nxi<lint>(),lim_b=nxi<lint>();
	for(int i=1; i<=n; ++i){
		val[i]=nxi<lint>();
	}
	val[0]=-2e18;
	val[n+1]=2e18;
	pre_dp[0][0]=pre_dp[0][1]=1;
	for(int ptl_a=0,ptl_b=0,ptr_a=-1,ptr_b=-1,i=1; i<=n; ++i){
		if(val[i]-val[i-1]<lim_a) ptl_a=i-1;
		if(val[i]-val[i-1]<lim_b) ptl_b=i-1;
		while(ptr_a<i-1&&val[i+1]-val[ptr_a+1]>=lim_b) ++ptr_a;
		while(ptr_b<i-1&&val[i+1]-val[ptr_b+1]>=lim_a) ++ptr_b;
		//pre_dp[i][0]=get_dp(ptl_a,ptr_a);
		//pre_dp[i][1]=get_dp(ptl_b,ptr_b);
		pre_dp[i][0]=(pre_dp[i-1][0]+get_dp(ptl_a,ptr_a,1))%mod;
		pre_dp[i][1]=(pre_dp[i-1][1]+get_dp(ptl_b,ptr_b,0))%mod;
	}
	const int ans_0=(pre_dp[n][0]-pre_dp[n-1][0]+mod)%mod;
	const int ans_1=(pre_dp[n][1]-pre_dp[n-1][1]+mod)%mod;
	printf("%d\n",(ans_0+ans_1)%mod);
	return 0;
}