#include <cstdio>
#include <vector>
#include <algorithm>
#include <functional>
#include <tuple>
#include <map>
#include <unordered_map>
#include <set>
#include <unordered_set>
#include <array>
#include <valarray>

using namespace std;

constexpr int mod = 1000000007;

// modをとった和を返す
inline
int modPlus(int a, int b){return (a + b) % mod;}

// modをとった差を返す
inline
int modMinus(int a, int b){return (mod + a - b) % mod;}

// modをとった積を返す
inline
int modMultiple(int a, int b){return (static_cast<long long>(a) * b) % mod;}


// 階乗数n!を最初に計算して、呼ばれた時に返す
class Factorial {
    std::vector<int> table;
public:
    Factorial(int max) : table(max) // max:テーブルのサイズ
    {
        table[0] = 1;
        for (int i = 1; i < max; ++i){
            table[i] = modMultiple(table[i - 1], i + 1);
        }
    }

    int operator () (int n)
    {
        if (n < 0) return 0;
        if (n == 0) return 1;
        return table[n - 1];
    }
};

// 階上数n!の逆数（逆元）を最初に計算して、呼ばれた時に返す
class FactorialInverse {
    std::vector<int> table;
    Factorial& fact;
public:
    FactorialInverse(int max, Factorial fact) : table(max), fact(fact) // max:テーブルのサイズ
    {
        int digit  = 0;
        {
            int temp = mod - 2;
            while (temp > 0){
                temp >>= 1;
                ++digit;
            }
        }
        int origin = fact(max);
        std::vector<int> powerorigin2(digit);
        powerorigin2[0] = origin;
        for (int i = 1; i < digit; ++i){
            powerorigin2[i] = modMultiple(powerorigin2[i - 1], powerorigin2[i - 1]);
        }
        {
            int table_max = 1;
            int temp = mod - 2;
            for (int i = 0; temp > 0; ++i, temp >>= 1){
                if (!(temp & 1)) continue;
                table_max = modMultiple(table_max, powerorigin2[i]);
            }
            table[max - 1] = table_max; // origin^(mod - 2)
        }
        for (int i = max - 2; i >= 0; --i){
            table[i] = modMultiple(table[i + 1], i + 2);
        }
    }

    int operator () (int n)
    {
        if (n < 0) return 0;
        if (n == 0) return 1;
        return table[n - 1];
    }
};

// N^xを最初に計算して、呼ばれた時に返す
class PowerN {
    std::vector<int> table;
public:
    PowerN(unsigned int N, int max) : table(max) // max:テーブルのサイズ
    {
        table[0] = N;
        for (int i = 1; i < max; ++i){
            table[i] = modMultiple(table[i - 1], N);
        }
    }

    int operator () (int n)
    {
        if (n < 0) return 0;
        if (n == 0) return 1;
        return table[n - 1];
    }
};

// int nCr = [&](int n, int r){
//     return modMultiple(modMultiple(fact(n), factinv(r)), factinv(n - r));
// };

using ll = long long;

int main()
{
    int N;
    ll A, B;
    scanf("%d %lld %lld\n", &N, &A, &B);
    if (N == 0){
        printf("%d\n", 1); return 0;
    }
    if (N == 1){
        printf("%d\n", 2); return 0;
    }
    // vector<vector<int>> table(N + 1, vector<int>(N + 1, 0));
    // table[0][0] = 1;
    // table[1][0] = 1;
    // table[0][1] = 1;
    // vector<int> X(N, 0); X[0] = 1;
    // vector<int> Y(N, 0); Y[0] = 1;
    vector<int> X_sum; X_sum.reserve(N); X_sum.emplace_back(1);
    vector<int> Y_sum; Y_sum.reserve(N); Y_sum.emplace_back(1);
    vector<ll> S; S.reserve(N + 1); S.emplace_back(-max(A, B));
    int X_nonzero_i = 0;
    int Y_nonzero_i = 0;
    for (int i = 1; i <= N; ++i){
        ll Si;
        scanf("%lld\n", &Si);
        S.emplace_back(Si);
        // if (i == 1) printf("%2d: %d %d\n", Si, X_sum.back(), Y_sum.back());
        // if (i == 1) printf("%d \n%d \n", Si, X[0], Y[0]);
        if (i == 1) continue;

        // bool X_flag = (Si >= S[i - 1] + A);
        // bool Y_flag = (Si >= S[i - 1] + B);
        // for (int j = 0; j < i - 1; ++j){
        //     if (X_flag) table[i][j] = table[i - 1][j];
        //     if (Y_flag) table[j][i] = table[j][i - 1];
        //     if (Si >= S[j] + B) table[i - 1][i] = modPlus(table[i - 1][j], table[i - 1][i]);
        //     if (Si >= S[j] + A) table[i][i - 1] = modPlus(table[j][i - 1], table[i][i - 1]);
        // }
        // for (int j = 0; j < i - 1; ++j){
        //     if (Si >= S[j] + B) Y[i - 1] += X[j];
        //     if (Si >= S[j] + A) X[i - 1] += Y[j];
        // }
        // if (!X_flag) for (int j = 0; j < i - 1; ++j) X[j] = 0;
        // if (!Y_flag) for (int j = 0; j < i - 1; ++j) Y[j] = 0;

        int next_X_i = distance(S.begin(), upper_bound(S.begin(), S.end() - 2, Si - A)) - 1;
        int next_Y_i = distance(S.begin(), upper_bound(S.begin(), S.end() - 2, Si - B)) - 1;
        if (next_X_i >= Y_nonzero_i){
            X_sum.emplace_back(Y_sum[next_X_i]);
        }else{
            X_sum.emplace_back(0);
        }
        if (next_Y_i >= X_nonzero_i){
            Y_sum.emplace_back(X_sum[next_Y_i]);
        }else{
            Y_sum.emplace_back(0);
        }

        if (Si - A >= S[i - 1]){
            X_sum[i - 1] = modPlus(X_sum[i - 2], X_sum[i - 1]);
        }else{
            X_nonzero_i = i - 1;
        }
        if (Si - B >= S[i - 1]){
            Y_sum[i - 1] = modPlus(Y_sum[i - 2], Y_sum[i - 1]);
        }else{
            Y_nonzero_i = i - 1;
        }

        // printf("%2d: %d %d\n", Si, X_sum.back(), Y_sum.back());
        // for (int j = 0; j < i; ++j) printf("%d ", X[j]); printf(": ");
        // for (int j = 0; j < i; ++j) printf("%d ", ((j >= X_nonzero_i) ? X_sum[j] : 0)); puts("");
        // for (int j = 0; j < i; ++j) printf("%d ", Y[j]); printf(": ");
        // for (int j = 0; j < i; ++j) printf("%d ", ((j >= Y_nonzero_i) ? Y_sum[j] : 0)); puts("");
    }
    // for (auto& row : table){
    //     for (auto& elem : row){
    //         printf("%2d ", elem);
    //     } puts("");
    // }
    int result = 0;
    result = modPlus(X_sum.back(), result);
    result = modPlus(Y_sum.back(), result);
    // for (int i = 0; i <= N; ++i){
        // result = modPlus(table[N][i], result);
        // result = modPlus(table[i][N], result);
    // }
    printf("%d\n", result);
}


Measured memory_bytes: 1792