// Original C++ solution (slower):
#include <bits/stdc++.h>

using namespace std;



#define int long long



int dx[] = {1, 0, -1, 0, 1, -1, -1, 1};

int dy[] = {0, 1, 0, -1, 1, 1, -1, -1};



/*

#define cin ifs

#define cout ofs

ifstream ifs("in.txt");

ofstream ofs("out.txt");

//*/



int N, A, B, S[100001];

int mod = 1e9 + 7;



// Binary Indexed Tree(1-indexed)

const int MAX_N = 100001;



struct BIT {

    int n, bit[MAX_N + 1] = {};



    int sum(int i) {

        int s = 0;

        while (i > 0) {

            s += bit[i];

            s %= mod;

            i -= i & -i;

        }

        return s;

    }



    void add(int i, int x) {

        while (i <= n) {

            bit[i] += x;

            bit[i] += mod;

            bit[i] %= mod;

            i += i & -i;

        }

    }

};



signed main() {

    cin >> N >> A >> B;

    S[0] = -2e18;

    for (int i = 1; i <= N; i++) {

        cin >> S[i];

    }

    if (A > B)

        swap(A, B);

    for (int i = 3; i <= N; i++) {

        if (S[i] - S[i - 2] < A) {

            cout << 0 << endl;

            return 0;

        }

    }

    int last_zero = 0;

    BIT dp = {N + 1};

    dp.add(1, 1);

    for (int i = 1; i <= N; i++) {

        int lb = -1, ub = N;

        while (ub - lb > 1) {

            int mid = (lb + ub) / 2;

            if (S[i] - S[mid] >= B) {

                lb = mid;

            } else {

                ub = mid;

            }

        }

        dp.add(i + 1, dp.sum(lb + 1));

        if (S[i] - S[i - 1] < A) {

            for (int j = last_zero; j < i - 1; j++) {

                dp.add(j + 1, -dp.sum(j + 1));

            }

            last_zero = i - 1;

        }

    }

    cout << dp.sum(N + 1) << endl;

    return 0;

}

// Optimized solution to the same problem (faster):
#include <bits/stdc++.h>

using namespace std;



#define int long long

#define rep(i, n) for (int i = 0; i < (int) (n); i++)

#define reps(i, n) for (int i = 1; i <= (int) (n); i++)

#define all(x) (x).begin(), (x).end()

#define uniq(x) (x).erase(unique(all(x)), (x).end())

#define bit(n) (1LL << (n))

#define cdiv(a, b) (((a) - 1) / (b) + 1)

#define dump(x) cerr << #x " = " << (x) << endl

using vint = vector<int>;

using vvint = vector<vint>;

using pint = pair<int, int>;

using vpint = vector<pint>;

template<typename T> using priority_queue_rev = priority_queue<T, vector<T>, greater<T>>;

constexpr double PI = 3.1415926535897932384626433832795028;

constexpr int DY[8] = {0, 1, 0, -1, 1, 1, -1, -1};

constexpr int DX[8] = {1, 0, -1, 0, 1, -1, -1, 1};

int gcd(int a, int b) {

    while (b) { swap(a %= b, b); }

    return a;

}

int lcm(int a, int b) { return a / gcd(a, b) * b; }

template<typename T> void fin(T mes) {

    cout << mes << endl;

    exit(0);

}

template<typename T, typename U> bool chmax(T &a, const U &b) {

    if (a < b) {

        a = b;

        return true;

    }

    return false;

}

template<typename T, typename U> bool chmin(T &a, const U &b) {

    if (b < a) {

        a = b;

        return true;

    }

    return false;

}

template<typename T, typename U> ostream &operator<<(ostream &os, const pair<T, U> &rhs) {

    os << "(" << rhs.first << ", " << rhs.second << ")";

    return os;

}

template<typename T> ostream &operator<<(ostream &os, const vector<T> &rhs) {

    os << "{";

    for (auto itr = rhs.begin(); itr != rhs.end(); itr++) {

        os << *itr << (next(itr) != rhs.end() ? ", " : "");

    }

    os << "}";

    return os;

}

struct setup {

    static constexpr int PREC = 20;

    setup() {

        cout << fixed << setprecision(PREC);

        cerr << fixed << setprecision(PREC);

    };

} setup;



template<int MOD = 1000000007>

struct mod_int {

    int val;

    mod_int(long long val_ = 0) : val(val_ % MOD) { if (val < 0) { val += MOD; }}

    bool operator==(const mod_int &rhs) const { return val == rhs.val; }

    bool operator!=(const mod_int &rhs) const { return std::rel_ops::operator!=(*this, rhs); }

    mod_int &operator+=(const mod_int &rhs) {

        if ((val += rhs.val) >= MOD) { val -= MOD; }

        return *this;

    }

    mod_int &operator-=(const mod_int &rhs) {

        if ((val += MOD - rhs.val) >= MOD) { val -= MOD; }

        return *this;

    }

    mod_int &operator*=(const mod_int &rhs) {

        val = (int) ((long long) val * rhs.val % MOD);

        return *this;

    }

    mod_int &operator/=(const mod_int &rhs) { return *this *= rhs.inv(); }

    mod_int operator+() const { return *this; }

    mod_int operator-() const { return -val; }

    mod_int operator++() { return *this += 1; }

    mod_int operator--() { return *this -= 1; }

    mod_int operator++(signed) {

        const mod_int ret(*this);

        ++*this;

        return ret;

    }

    mod_int operator--(signed) {

        const mod_int ret(*this);

        --*this;

        return ret;

    }

    mod_int operator+(const mod_int &rhs) const { return mod_int(*this) += rhs; }

    mod_int operator-(const mod_int &rhs) const { return mod_int(*this) -= rhs; }

    mod_int operator*(const mod_int &rhs) const { return mod_int(*this) *= rhs; }

    mod_int operator/(const mod_int &rhs) const { return mod_int(*this) /= rhs; }

    mod_int inv() const {

        assert(val != 0);

        int a = val, b = MOD, x = 1, u = 0;

        while (b) {

            int t = a / b;

            std::swap(a -= t * b, b);

            std::swap(x -= t * u, u);

        }

        return x;

    }

    mod_int pow(long long n) const {

        if (n < 0) { return pow(-n).inv(); }

        mod_int ret = 1, mul = *this;

        while (n) {

            if (n & 1) { ret *= mul; }

            mul *= mul;

            n >>= 1;

        }

        return ret;

    }

    friend std::istream &operator>>(std::istream &is, mod_int &rhs) {

        long long v;

        is >> v;

        rhs = v;

        return is;

    }

    friend std::ostream &operator<<(std::ostream &os, const mod_int &rhs) { return os << rhs.val; }

    struct combination {

        std::vector<mod_int> fact{1, 1}, f_inv{1, 1}, inv{0, 1};

        void calc(int n) {

            while (fact.size() <= n) {

                int i = fact.size();

                fact.push_back(fact[i - 1] * i);

                inv.push_back(-inv[MOD % i] * (MOD / i));

                f_inv.push_back(f_inv[i - 1] * inv[i]);

            }

        }

        mod_int P(int n, int r) { return r < 0 || n < r ? 0 : (calc(n), fact[n] * f_inv[n - r]); }

        mod_int C(int n, int r) { return r < 0 || n < r ? 0 : (calc(n), fact[n] * f_inv[r] * f_inv[n - r]); }

        mod_int H(int n, int r) { return C(n + r - 1, r); }

    };

};



template<typename M>

struct fenwick_tree {

    using T = typename M::T;

    int n;

    std::vector<T> data;

    fenwick_tree(int n) : n(n), data(n + 1, M::id()) {}

    void add(int i, const T &x) {

        assert(0 <= i && i < n);

        for (i++; i <= n; i += i & -i) { data[i] = M::op(data[i], x); }

    }

    T get_sum(int i) const {

        assert(0 <= i && i <= n);

        T ret = M::id();

        for (; i > 0; i -= i & -i) { ret = M::op(ret, data[i]); }

        return ret;

    }

    T get_sum(int l, int r) const {

        assert(0 <= l && l < n);

        assert(0 < r && r <= n);

        return M::op(get_sum(r), M::inv(get_sum(l)));

    }

};



using mint=mod_int<>;

struct rsq {

    using T = mint;

    static T id() { return 0; }

    static T op(const T &a, const T &b) { return a + b; }

    static T inv(const T &a) { return -a; }

};



template<typename F> long long discrete_binary_search(long long ok, long long ng, F is_ok) {

    while (abs(ok - ng) > 1) {

        long long mid = (ok + ng) / 2;

        (is_ok(mid) ? ok : ng) = mid;

    }

    return ok;

}



int N, A, B;

int S[110000];

signed main() {

    cin >> N >> A >> B;

    if (A > B) { swap(A, B); }

    reps(i, N) { cin >> S[i]; }

    S[0] = -1e18;

    reps(i, N - 2) { if (S[i + 2] - S[i] < A) { fin(0); }}

    fenwick_tree<rsq> dp(N + 1);

    dp.add(0, 1);

    int m = 1;

    reps(i, N) {

        int k = discrete_binary_search(0, i, [&](int x) {

            return S[i] - S[x] >= B;

        });

        if (m - 1 <= k) { dp.add(i, dp.get_sum(m - 1, k + 1)); }

        if (S[i] - S[i - 1] < A) { m = i; }

    }

    cout << dp.get_sum(m - 1, N + 1) << endl;

}


// Fastest known solution for this problem: