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<bits/stdc++.h>
#define ll long long

const int N = 100010;
const int moder = 1e9 + 7;

ll dp[2][N], pre[2][N], a[N], n, A, B;
std::map <ll, ll> Hash;

int main(){
	scanf("%lld%lld%lld", &n, &A, &B);
	for (int i = 1; i <= n; ++ i){
		scanf("%lld", &a[i]);
		Hash[- a[i]] = i;
	}
	dp[0][0] = dp[1][0] = pre[0][0] = pre[1][0] = 1;
	int now1 = 0, now2 = 0;
	for (int i = 2; i <= n; ++ i){
		auto u = Hash.lower_bound(B - a[i]);
		int sit = u == Hash.end() ? 0 : u -> second;
		if (sit == i - 1){
			-- sit;
		}
		dp[1][i - 1] = pre[0][sit];
		u = Hash.lower_bound(A - a[i]);
		sit = u == Hash.end() ? 0 : u -> second;
		if (sit == i - 1){
			-- sit;
		}
		dp[0][i - 1] = pre[1][sit];
		if (a[i] - a[i - 1] < A){
			for (int j = now1; j < i - 1; ++ j){
				dp[0][j] = pre[0][j] = 0;
			}
			now1 = i - 1;
		}
		if (a[i] - a[i - 1] < B){
			for (int j = now2; j < i - 1; ++ j){
				dp[1][j] = pre[1][j] = 0;
			}
			now2 = i - 1;
		}
		pre[1][i - 1] = (pre[1][i - 2] + dp[1][i - 1]) % moder;
		pre[0][i - 1] = (pre[0][i - 2] + dp[0][i - 1]) % moder;
	}
	ll ans = 0;
	for (int i = 0; i < n; ++ i){
		ans = (ans + dp[0][i] + dp[1][i]) % moder;
	}
	printf("%lld", ans);
	return 0;
}