#pragma GCC target("avx2")
#pragma GCC optimization("O3")
#pragma GCC optimization("unroll-loops")
#include <algorithm>
#include <assert.h>
#include <bitset>
#include <cfloat>
#include <complex>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <string.h>
#include <time.h>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#define rep(i,n) for(int i=0;i<(n);i++)
#define REP(i,n) for(int i=1;i<=(n);i++)
#define int long long
#define ll long long
#define mod (int)1000000007
#define P pair<int,int>
#define prique(T) priority_queue<T,vector<T>,greater<T>>
#define all(V) V.begin(),V.end()
#ifdef int
constexpr int INF = LLONG_MAX / 10;
#else
constexpr int INF = INT_MAX / 10;
#endif
constexpr double eps = DBL_EPSILON;
template <class T, class U>
inline bool chmax(T& lhs, const U& rhs) {
	if (lhs < rhs) {
		lhs = rhs;
		return 1;
	}
	return 0;
}
template <class T, class U>
inline bool chmin(T& lhs, const U& rhs) {
	if (lhs > rhs) {
		lhs = rhs;
		return 1;
	}
	return 0;
}
using namespace std;
inline int gcd(int a, int b) {
	while (b) {
		int c = a;
		a = b; b = c % b;
	}
	return a;
}
inline int lcm(int a, int b) {
	return a / gcd(a, b) * b;
}
bool isprime(int n) {
	if (n == 1)return false;
	for (int i = 2; i * i <= n; i++) {
		if (n % i == 0)return false;
	}
	return true;
}
int mypow(int a, int b) {
	if (!b)return 1;
	if (b & 1)return mypow(a, b - 1) * a;
	int memo = mypow(a, b >> 1);
	return memo * memo;
}
int modpow(int a, int b, int m = mod) {
	if (!b)return 1;
	if (b & 1)return modpow(a, b - 1, m) * a % m;
	int memo = modpow(a, b >> 1, m);
	return memo * memo % m;
}
class modInt {
	int value, modulo;
public:
	modInt() : value(0), modulo(mod) { value = 0; }
	template<typename T>
	modInt(T value = 0, int modulo = mod) : value(value), modulo(modulo) {
		if (value < 0) {
			value = -value;
			value %= modulo;
			value = -value;
			value += modulo;
		}
		this->value = value % modulo;
	}
	inline operator int()const { return value; }
	inline modInt& operator+=(modInt x) {
		value += x.value;
		if (value >= modulo)value -= modulo;
		return *this;
	}
	inline modInt& operator++() {
		if (value == modulo - 1)value = 0;
		else value++;
		return *this;
	}
	inline modInt& operator-()const {
		return modInt(0) -= *this;
	}
	inline modInt& operator-=(modInt x) {
		value -= x.value;
		if (value < 0)value += modulo;
		return *this;
	}
	inline modInt& operator--() {
		if (value == 0)value = modulo - 1;
		else value--;
		return *this;
	}
	inline modInt& operator*=(modInt x) {
		value = value * x.value % modulo;
		return *this;
	}
	inline modInt& operator/=(modInt x) {
		return operator*=(x.inv());
	}
	inline modInt inv() {
		return modpow(*this, modulo - 2);
	}
	template<typename T> modInt operator+(T x) { return modInt(*this) += x; }
	template<typename T> modInt& operator+=(T x) { return operator+=(modInt(x, modulo)); }
	template<typename T> modInt operator-(T x) { return modInt(*this) -= x; }
	template<typename T> modInt& operator-=(T x) { return operator-=(modInt(x, modulo)); }
	template<typename T> modInt operator*(T x) { return modInt(*this) *= x; }
	template<typename T> modInt& operator*=(T x) { return operator*=(modInt(x, modulo)); }
	template<typename T> modInt operator/(T x) { return modInt(*this) /= x; }
	template<typename T> modInt& operator/=(T x) { return operator/=(modInt(x, modulo)); }
};
istream& operator>>(istream& ist, modInt& x) {
	int a;
	ist >> a;
	x = a;
	return ist;
}
modInt modpow(modInt a, int b) {
	if (!b)return modInt(1);
	if (b & 1)return modpow(a, b - 1) * a;
	modInt memo = modpow(a, b / 2);
	return memo * memo;
}
template<typename T>
class SparseTable {
	T** table;
	int* logtable;
	bool ismax;
public:
	SparseTable(vector<T> vec, bool ismax = false) :ismax(ismax) {
		int maxlength = 0;
		while ((1 << (maxlength + 1)) <= vec.size())maxlength++;
		table = new T * [maxlength + 1];
		logtable = new int[vec.size() + 1];
		rep(i, maxlength + 1) {
			table[i] = new T[vec.size()];
			rep(j, vec.size() - (1 << i) + 1) {
				if (i) {
					if (!ismax)table[i][j] = min(table[i - 1][j], table[i - 1][j + (1 << (i - 1))]);
					else table[i][j] = max(table[i - 1][j], table[i - 1][j + (1 << (i - 1))]);
				}
				else table[i][j] = vec[j];
			}
		}
		logtable[1] = 0;
		for (int i = 2; i <= vec.size(); i++) {
			logtable[i] = logtable[i >> 1] + 1;
		}
	}
	T query(int l, int r) {
		assert(l < r);
		int length = r - l;
		if (!ismax)return min(table[logtable[length]][l], table[logtable[length]][r - (1 << logtable[length])]);
		else return max(table[logtable[length]][l], table[logtable[length]][r - (1 << logtable[length])]);
	}
};
int n, a, b, s[100010];
modInt dp[100010][2];
signed main() {
	cin >> n >> a >> b;
	rep(i, n)cin >> s[i];
	vector<int> diff;
	rep(i, n - 1)diff.push_back(s[i + 1] - s[i]);
	SparseTable<int> st(diff);
	dp[0][0] = dp[0][1] = 1;
	REP(i, n - 1) {
		if (s[i] - s[i - 1] >= a) {
			dp[i][0] = dp[i - 1][0] + dp[i - 1][1];
		}
		else {
			int l = upper_bound(s, s + i, s[i] - a) - s;
			if (l == i - 1)dp[i][0] = dp[l][1];
			else if (st.query(l, i - 1) >= b)dp[i][0] = dp[l][1];
		}
		if (s[i] - s[i - 1] >= b) {
			dp[i][1] += dp[i - 1][0] + dp[i - 1][1];
		}
		else {
			int l = upper_bound(s, s + i, s[i] - b) - s;
			if (l == i - 1)dp[i][1] = dp[l][0];
			else if (st.query(l, i - 1) >= a)dp[i][1] = dp[l][0];
		}
	}
	cout << dp[n - 1][0] + dp[n - 1][1] << endl;
	return 0;
}

Measured memory_bytes: 18932