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

using namespace std;



typedef long long ll;

const int mod = 1000*1000*1000+7;

const int MN = 100010;



int N;

ll A, B;

vector<ll> S;



struct BIT {

    ll tree[4*MN];

    void init() {

        memset(tree, 0, sizeof(tree));

    }

    void build(int l, int r, int n) {

        if(l == r) {

            tree[n] = (l == 0? S[l] : S[l] - S[l - 1]);

            return;

        }

        int m = (l + r)>>1;

        build(l, m, 2*n);

        build(m + 1, r, 2*n + 1);

        tree[n] = min(tree[2*n], tree[2*n + 1]);

    }

    ll quer(int a, int b, int l, int r, int n) {

        if(b < l || r < a) return 1e18;

        if(a <= l && r <= b) return tree[n];

        int m = (l + r)>>1;

        ll L = quer(a, b, l, m, 2*n);

        ll R = quer(a, b, m + 1, r, 2*n + 1);

        return min(L, R);

    }

} bit;



int cc[100010];

int dp(int idx) {

    int &ret = cc[idx];

    if(ret != -1) return ret;



    if(idx == N) return ret = 1;



    ret = 0;

    if(idx == 0 || S[idx] - S[idx - 1] >= B) {

        ret += dp(idx + 1);

        ret %= mod;

    }



    int s = idx + 1, e = N - 1;

    int x = N;

    while(s <= e) {

        int m = (s + e)>>1;



        if(S[m] - S[idx] >= A) {

            x = m;

            e = m - 1;

        }

        else s = m + 1;

    }



    if(((idx != N - 1 && idx >= 1)? S[idx + 1] - S[idx - 1] >= B : 1) && bit.quer(idx + 2, x - 1, 0, N - 1, 1) >= B) {

        ret += dp(x);

        ret %= mod;

    }



    return ret;

}



int main() {

    scanf("%d %lld %lld", &N, &A, &B);

    S.resize(N);

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

        scanf("%lld", &S[i]);

    }



    if(A < B) swap(A, B);



    bit.init();

    bit.build(0, N - 1, 1);

    memset(cc, -1, sizeof(cc));



    printf("%d", dp(0));

}


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

using namespace std;



typedef long long ll;



const int mod = 1e9 + 7;

const int MN = 100010;



int N;

ll A, B;

ll S[MN];

int psum[MN], dp[MN];



int calc(int l, int r) {

    if(l > r) return 0;

    return psum[r] - (l? psum[l - 1] : 0);

}



struct Fenwick {

    vector<int> tree;

    void init() {

        tree = vector<int>(MN + 1, 0);

    }

    void upd(int idx, int val) {

        for(int i = idx + 1; i <= MN; i += (i & -i)) tree[i] += val, tree[i] %= mod;

    }

    int quer(int a) {

        int ret = 0;

        for(int i = a + 1; i >= 1; i -= (i & -i)) ret += tree[i], ret %= mod;

        return ret;

    }

    int quer(int a, int b) {

        if(a > b) return 0;

        return (quer(b) + mod - quer(a - 1)) % mod;

    }

} fw;



int main() {

    scanf("%d %lld %lld", &N, &A, &B);

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



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

        scanf("%lld", &S[i]);

    }



    for(int i = 0; i < N - 2; i++) {

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

            printf("0");

            return 0;

        }

    }



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

        psum[i] = S[i] - S[i - 1] < A;

        psum[i] += psum[i - 1];

    }



    fw.init();

    dp[N] = 1;

    fw.upd(N, dp[N]);



    int pos1 = N;

    int pos2 = N;

    for(int i = N - 1; i >= 0; i--) {

        while(pos1 >= 1 && S[pos1 - 1] - S[i] >= B) pos1--;

        while(pos2 >= 0 && calc(i + 2, pos2 - 1)) pos2--;

        dp[i] = fw.quer(pos1, pos2);

        fw.upd(i, dp[i]);

    }

    int ans = 0;

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

        if(!calc(0, i - 1)) ans += dp[i], ans %= mod;

    }

    printf("%d", ans);

}


// Fastest known solution for this problem: