Problem:
Score : 1100 points

Problem Statement

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.

Sample Input 1

5 3 7
1
3
6
9
12

Sample Output 1

5

There are five ways to perform division:

X={1,6,9,12}, Y={3}

X={1,6,9}, Y={3,12}

X={3,6,9,12}, Y={1}

X={3,6,9}, Y={1,12}

X={3,6,12}, Y={1,9}

Sample Input 2

7 5 3
0
2
4
7
8
11
15

Sample Output 2

4

Sample Input 3

8 2 9
3
4
5
13
15
22
26
32

Sample Output 3

13

Sample Input 4

3 3 4
5
6
7

Sample Output 4

0

Solution in C++14 (GCC 5.4.1) (judge verdict: Accepted)

// by sntea, https://beta.atcoder.jp/contests/agc009/submissions/1942084

#ifdef LOCAL111
	#define _GLIBCXX_DEBUG
#else
	#define NDEBUG
#endif
#define _USE_MATH_DEFINES
#include <bits/stdc++.h>
const long long INF = 1e18+199;
using namespace std;
template<typename T, typename U> ostream& operator<< (ostream& os, const pair<T,U>& p) { os << '(' << p.first << ' ' << p.second << ')'; return os; }
 
#define endl '\n'
#define ALL(a)  (a).begin(),(a).end()
#define SZ(a) int((a).size())
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define RFOR(i,a,b) for (int i=(b)-1;i>=(a);i--)
#define REP(i,n)  FOR(i,0,n)
#define RREP(i,n) for (int i=(n)-1;i>=0;i--)
#ifdef LOCAL111
	#define DEBUG(x) cout<<#x<<": "<<(x)<<endl
	template<typename T> void dpite(T a, T b){ for(T ite = a; ite != b; ite++) cout << (ite == a ? "" : " ") << *ite; cout << endl;}
#else
	#define DEBUG(x) true
	template<typename T> void dpite(T a, T b){ return; }
#endif
#define F first
#define S second
#define SNP string::npos
#define WRC(hoge) cout << "Case #" << (hoge)+1 << ": "
template<typename T> void pite(T a, T b){ for(T ite = a; ite != b; ite++) cout << (ite == a ? "" : " ") << *ite; cout << endl;}
template<typename T> bool chmax(T& a, T b){if(a < b){a = b; return true;} return false;}
template<typename T> bool chmin(T& a, T b){if(a > b){a = b; return true;} return false;}
 
typedef long long int LL;
typedef unsigned long long ULL;
typedef pair<int,int> P;
 
void ios_init(){
	//cout.setf(ios::fixed);
	//cout.precision(12);
#ifdef LOCAL111
	return;
#endif
	ios::sync_with_stdio(false); cin.tie(0);	
}
 
//区間更新 区間minクエリ
template<typename T>
class LazySegmentTree{
private:
	vector<T> dat;
	vector<T> lazy;
	vector<bool> lazyf;
	T e;
	// T lazyinit;
	int n;
	
public:
	LazySegmentTree(int sz,T init, T linit){
		n = 1;
		while(sz > n) n <<= 1;
		dat = vector<T>(2*n,init);
		lazy = vector<T>(2*n,linit);
		lazyf = vector<bool>(2*n, false);
		e = init;
	}
 
	T f(T x, T y){
		return x+y;
	}
 
	int size() {return n;}
 
	void update(int l, int r, T t){
		function<T(int,int,int)> rec = [&](int x, int y, int k) -> T{
			prop(k);
			if(r <= x or y <= l) return dat[k];
			if(l <= x and y <= r){ //今見ている区間が完全に含まれる
				lazyf[k] = true;
				lazy[k] = t;
				prop(k);
				return dat[k];
			}else{
				int m = x+(y-x)/2;
				prop(k);
				auto tmp = f(rec(x,m,2*k+1),rec(m,y,2*k+2));
				return dat[k] = tmp;
			}
		};
		rec(0,n,0);
	}
 
	void prop(int k){
		if(!lazyf[k]) return;
		dat[k] = lazy[k];
		if(2*k+1 < 2*n){
			lazyf[2*k+1] = true;
			lazy[2*k+1] = lazy[k];
		}
		if(2*k+2 < 2*n){
			lazyf[2*k+2] = true;
			lazy[2*k+2] = lazy[k];
		}
		lazyf[k] = false;
	}
 
	void lazy_prop(int l, int r){
		function<void(int,int,int)> rec = [&](int a, int b, int k){
			if(r <= a or b <= l) return;
			int m = a+(b-a)/2;
			prop(k);
			if(!(l <= a and b <= r)){
				rec(a,m,2*k+1);
				rec(m,b,2*k+2);
			}
		};
		rec(0,n,0);
	}
 
	T query(int l, int r){
		lazy_prop(l,r);
		function<T(int,int,int)> rec = [&](int a, int b, int k) -> T{
			if(r <= a or b <= l) return e;
			int m = a+(b-a)/2;
			if(l <= a and b <= r){
				return dat[k];
			}else{
				return f(rec(a,m,2*k+1),rec(m,b,2*k+2));
			}
		};
		return rec(0,n,0);
	}
 
	// void debug(){
	// 	for(int i = 0; i < n; i++) query(i, i+1);
	// 	dpite(ALL(dat));
	// 	dpite(ALL(lazy));
	// }
};
 
template<long long MOD>
class ModInt {
public:
	const static long long mod = MOD;
	long long x;
	
	ModInt() {
		x = 0;
	}
 
	ModInt(long long x) {
		x %= mod;
		this->x = x < 0 ? x+mod : x;
	}
 
	int get() const {
		return (int)x;
	}
 
	ModInt &operator+=(ModInt that) {
		if((x += that.get()) >= mod) x -= mod;
		return *this;
	}
 
	ModInt &operator-=(ModInt that) {
		if((x += mod-that.get()) >= mod) x -= mod;
		return *this;
	}
 
	ModInt &operator*=(ModInt that) {
		x = x*that.get()%mod;
		return *this;
	}
 
	ModInt &operator/=(ModInt that) {
		return *this *= that.inverse();
	}
 
	ModInt operator+(ModInt that) const {
		return ModInt(*this) += that;
	}
 
	ModInt operator-(ModInt that) const {
		return ModInt(*this) -= that;
	}
 
	ModInt operator*(ModInt that) const {
		return ModInt(*this) *= that;
	}
 
	ModInt operator/(ModInt that) const {
		return ModInt(*this) /= that;
	}
 
	ModInt inverse() const {
		using std::swap;
		long long a = x, b = mod, u = 1, v = 0;
		while(b) {
			long long t = a/b;
			a -= t*b; swap(a,b);
			u -= t*v; swap(u,v);
		}
		return ModInt(u);
	}
 
	ModInt pow(int n) const{
		ModInt b = *this;
		ModInt res = 1;
		while(n != 0) {
			if(n&1){
				res *= b;
			}
			b *= b;
			n >>= 1;
		}
		return res;
	}
 
	bool operator==(ModInt that) const { return x == that.get(); }
	bool operator!=(ModInt that) const { return x != that.get(); }
	ModInt operator-() const { return x == 0 ? 0 : ModInt(mod-x); }
};
 
template<long long MOD> ostream& operator<< (ostream& os, const ModInt<MOD>& m) { os << m.get(); return os; }
template<long long MOD> istream& operator>> (istream& is, ModInt<MOD>& m){ long long n; is >> n; m = n; return is;}
typedef ModInt<1000000007> mint;
 
 
int main()
{
	ios_init();
	int n;
	LL a, b;
	while(cin >> n >> a >> b) {
		vector<LL> s(n+2);
		s[0] = -INF;
		s[1] = -INF;
		REP(i,n) cin >> s[i+2];
		n += 2;
		vector<LazySegmentTree<mint>> dp(2, LazySegmentTree<mint>(n, 0, 0));
		vector<LL> ab = {a, b};
		// REP(k, 2) {
		// 	dp[k].debug();
		// 	DEBUG(endl);
		// }
		dp[0].update(0, 1, 1);
		dp[1].update(0, 1, 1);
		// REP(k, 2) {
		// 	dp[k].debug();
		// 	DEBUG(endl);
		// }
		FOR(i, 2, n) {
			DEBUG(i);
			// mint val[2];
			REP(k, 2) {
				int p = upper_bound(ALL(s), s[i]-ab[1-k])-s.begin();
				DEBUG(p);
				DEBUG(dp[k].query(0, min(p, i-1)));
				dp[1-k].update(i-1, i, dp[k].query(0, min(p, i-1)));
			}
			REP(k, 2) {
				if(s[i]-s[i-1] < ab[k]) {
					dp[k].update(0, i-1, 0);
				}
			}
			// REP(k, 2) {
			// 	dp[k].debug();
			// 	DEBUG(endl);
			// }
		}
		mint ans = 0;
		REP(i, 2) {
			ans += dp[i].query(0, n);
		}
		cout << ans/2 << endl;
	}
	return 0;
}