// 解き直し.
// https://img.atcoder.jp/agc009/editorial.pdf
// #include <bits/stdc++.h>
// using namespace std;
// using LL = long long;
// #define repex(i, a, b, c) for(int i = a; i < b; i += c)
// #define repx(i, a, b) repex(i, a, b, 1)
// #define rep(i, n) repx(i, 0, n)
// #define repr(i, a, b) for(int i = a; i >= b; i--)
// const LL INF = 1e18;
// const LL MOD = 1e9 + 7;
// LL S[101010];
// LL dp[1010][1010]; // debug用.
// 
// int main(){
//     
//     // 1. 入力情報.
//     int N;
//     LL A, B;
//     scanf("%d %lld %lld", &N, &A, &B);
//     rep(i, N) scanf("%lld", &S[i + 1]);
//     S[0] = -INF;
//     
//     // 2. ゼロとなるパターン.
//     if(A > B) swap(A, B);
//     rep(i, N - 1){
//         if(S[i] + A > S[i + 2]){
//             puts("0");
//             return 0;
//         }
//     }
//     
//     // 3. dp更新.
//     dp[0][0] = 1;
//     repx(i, 1, N + 1){
//         // 3-1. S[i] を X に振り分ける場合.
//         // S[i] - S[i - 1] < A の 場合.
//         if(S[i] - S[i - 1] < A){
//             // rep(j, i - 1) dp[i][j] = 0;
//             dp[i][i - 1] = dp[i - 1][i - 1];
//             dp[i][i - 1] %= MOD;
//         }
//         
//         // S[i] - S[i - 1] >= A の 場合.
//         if(S[i] - S[i - 1] >= A){
//             rep(j, i) dp[i][j] = dp[i - 1][j], dp[i][j] %= MOD;
//         }
//         
//         // 3-2. S[i] を Y に 振り分ける場合.
//         rep(j, i) if(S[i] - S[j] >= B) dp[i][i] += dp[i - 1][j], dp[i][i] %= MOD;
//     }
//     // rep(i, N + 1){
//     //     rep(j, N + 1) printf("%lld ", dp[i][j]);
//     //     puts("");
//     // }
//     
//     // 4. 出力.
//     LL ans = 0;
//     rep(i, N + 1) ans += dp[N][i], ans %= MOD;
//     printf("%lld\n", ans);
//     return 0;
//     
// }
// 
// #include <bits/stdc++.h>
// using namespace std;
// using LL = long long;
// #define repex(i, a, b, c) for(int i = a; i < b; i += c)
// #define repx(i, a, b) repex(i, a, b, 1)
// #define rep(i, n) repx(i, 0, n)
// #define repr(i, a, b) for(int i = a; i >= b; i--)
// const LL INF = 1e18;
// const LL MOD = 1e9 + 7;
// LL S[101010];
// LL dp[101010]; // 高速化への準備(※二次元版から一次元版に変更).
// 
// int main(){
//     
//     // 1. 入力情報.
//     int N;
//     LL A, B;
//     scanf("%d %lld %lld", &N, &A, &B);
//     rep(i, N) scanf("%lld", &S[i + 1]);
//     S[0] = -INF;
//     
//     // 2. ゼロとなるパターン.
//     if(A > B) swap(A, B);
//     rep(i, N - 1){
//         if(S[i] + A > S[i + 2]){
//             puts("0");
//             return 0;
//         }
//     }
//     
//     // 3. dp更新.
//     dp[0] = 1;
//     repx(i, 1, N + 1){
//         // 3-1. S[i] を Y に 振り分ける場合.
//         // puts("----- 1. start -----");
//         rep(j, i) if(S[i] - S[j] >= B) dp[i] += dp[j], dp[i] %= MOD;
//         // printf("dp[%d]=%lld ", i, dp[i]);
//         // puts("\n----- 1. end -----");
//         
//         // 3-2. S[i] を X に振り分ける場合.
//         // S[i] - S[i - 1] < A の 場合.
//         if(S[i] - S[i - 1] < A){
//             // puts("----- 2. start -----");
//             rep(j, i - 1) dp[j] = 0; // printf("dp[%d]=%lld ", j, dp[j]);
//             // puts("");
//             // rep(j, i) printf("dp[%d]=%lld ", j, dp[j]);
//             // puts("\n----- 2. end -----");
//         }
//         
//         // S[i] - S[i - 1] >= A の 場合.
//         // ※ 何もしない.
//         if(S[i] - S[i - 1] >= A){
//             // puts("----- 3. start -----");
//             // rep(j, i) printf("dp[%d]=%lld ", j, dp[j]);
//             // puts("\n----- 3. end -----");
//         }
//         
//         // puts("----- 4. start -----");
//         // rep(j, N + 1) printf("%lld ", dp[j]);
//         // puts("");
//         // puts("\n----- 3. end -----");
//     }
//     // rep(i, N + 1) printf("%lld ", dp[i]);
//     // puts("");
//     
//     // 4. 出力.
//     LL ans = 0;
//     rep(i, N + 1) ans += dp[i], ans %= MOD;
//     printf("%lld\n", ans);
//     return 0;
//     
// }
//
// 高速化.
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
#define repex(i, a, b, c) for(int i = a; i < b; i += c)
#define repx(i, a, b) repex(i, a, b, 1)
#define rep(i, n) repx(i, 0, n)
#define repr(i, a, b) for(int i = a; i >= b; i--)
const LL INF = 1e18;
const LL MOD = 1e9 + 7;
LL S[101010];
LL dp[101010]; // 高速化.

// Binary Indexed Tree (Fenwick Tree)
// https://youtu.be/lyHk98daDJo?t=7960
// -> mod版 に 改変.
struct BIT{
    int n;
    vector<LL> d;
    BIT(int n = 0) : n(n), d(n + 1) {}
    void add(int i, LL x = 1){
        for(i++; i <= n; i += i & -i) d[i] += x, d[i] %= MOD;
    }
    LL sum(int i){
        LL x = 0;
        for(i++; i; i -= i & -i) x += d[i], x %= MOD;
        return x;
    }
    LL sum(int l, int r){
        return (sum(r - 1) - sum(l - 1) + MOD) % MOD;
    }
};

int main(){
    
    // 1. 入力情報.
    int N;
    LL A, B;
    scanf("%d %lld %lld", &N, &A, &B);
    rep(i, N) scanf("%lld", &S[i + 1]);
    S[0] = -INF;
    
    // 2. ゼロとなるパターン.
    if(A > B) swap(A, B);
    rep(i, N - 1){
        if(S[i] + A > S[i + 2]){
            puts("0");
            return 0;
        }
    }
    
    // 3. (Fenwick Treeを経由させる形で)dp更新.
    BIT ft(N + 2);
    dp[0] = 1;
    ft.add(0, 1LL);
    int at = 0; // 最初に 0 でなくなる位置.
    repx(i, 1, N + 1){
        // 3-1. S[i] を Y に 振り分ける場合.
        // lower_bound だと上手く行かないので注意.
        int y = upper_bound(S, S + N + 1, S[i] - B) - S;
        LL ySum = ft.sum(0, y);
        ft.add(i, ySum);
        dp[i] += ySum;
        
        // 3-2. S[i] を X に振り分ける場合.
        // S[i] - S[i - 1] < A の 場合.
        if(S[i] - S[i - 1] < A){
            repx(j, at, i - 1){
                LL t = ft.sum(j, j + 1);
                ft.add(j, MOD - t);
                dp[j] = 0;
            }
        }
        
        // S[i] - S[i - 1] >= A の 場合.
        // ※ 何もしない.
        if(S[i] - S[i - 1] >= A){
        }
        
        // 3-3. dp[i] が 最初に 0 でなくなる位置を更新.
        repx(j, at, N + 1){
            if(dp[j]){
                at = j;
                break;
            }
        }
    }
    
    // 4. 出力.
    LL ans = 0;
    rep(i, N + 1) ans += dp[i], ans %= MOD;
    printf("%lld\n", ans);
    return 0;
    
}

Measured memory_bytes: 5600