#include <bits/stdc++.h>
      
#define FOR(i,a,b) for( ll i = (a); i < (ll)(b); i++ )
#define REP(i,n) FOR(i,0,n)
#define YYS(x,arr) for(auto& x:arr)
#define ALL(x) (x).begin(),(x).end()
#define SORT(x) sort( (x).begin(),(x).end() )
#define REVERSE(x) reverse( (x).begin(),(x).end() )
#define UNIQUE(x) (x).erase( unique( ALL( (x) ) ) , (x).end() )
#define PW(x) (1LL<<(x))
#define SZ(x) ((ll)(x).size())
#define SHOW(x) cout << #x << " = " << x << endl
#define SHOWA(x,n) for( int yui = 0; yui < n; yui++ ){ cout << x[yui] << " "; } cout << endl

#define pb emplace_back
#define fi first
#define se second

using namespace std;

typedef long double ld;
typedef long long int ll;
typedef pair<int,int> pi;
typedef pair<ll,ll> pl;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<bool> vb;
typedef vector<ld> vd;
typedef vector<pi> vpi;
typedef vector<pl> vpl;
typedef vector<vpl> gr;
typedef vector<vl> ml;
typedef vector<vd> md;
typedef vector<vi> mi;
     
const ll INF = (ll)1e9 + 10;
const ll INFLL = (ll)1e18 + 10;
const ld EPS = 1e-12;
const ll MOD = 1e9+7;
     
template<class T> T &chmin( T &a , const T &b ){ return a = min(a,b); }
template<class T> T &chmax( T &a , const T &b ){ return a = max(a,b); }
template<class T> inline T sq( T a ){ return a * a; }

ll in(){ long long int x; scanf( "%lld" , &x ); return x; }
char yuyushiki[1000010]; string stin(){ scanf( "%s" , yuyushiki ); return yuyushiki; }

// head


struct Mod{
  unsigned n;
  Mod() : n(0){}
  Mod( ll x ){
    if( x < 0 ) n = x%MOD+MOD;
    else n = x%MOD;
  }
};
Mod operator + ( Mod a  , Mod b ){ return Mod( a.n + b.n ); }
Mod operator +=( Mod &a , Mod b ){ return a = a + b; }
Mod operator - ( Mod a ){ return Mod( MOD - a.n ); }
Mod operator - ( Mod a  , Mod b ){ return Mod( a.n + MOD - b.n ); }
Mod operator -=( Mod &a , Mod b ){ return a = a - b; }
Mod operator * ( Mod a  , Mod b ){ return Mod( (ll)a.n * b.n ); }
Mod operator *=( Mod &a , Mod b ){ return a = a * b; }
Mod modpow( Mod x , ll k ){
  Mod res = 1;
  while( k ){
    if( k & 1 ) res *= x;
    k /= 2;
    x *= x;
  }
  return res;
}
ll extgcd( ll a , ll b , ll &x , ll &y ){
  ll d = a;
  if( b != 0 ){
    d = extgcd( b , a % b , y , x );
    y -= a / b * x;
  } else {
    x = 1, y = 0;
  }
  return d;
}
Mod inv( Mod a ){ ll x, y; assert( extgcd( a.n , MOD , x , y ) == 1 ); return Mod( x ); }
Mod operator / ( Mod a  , Mod b ){ return Mod( (ll)a.n * inv(b).n ); }
Mod operator /=( Mod &a , Mod b ){ return a = a / b; }


ll n, a, b;
ll s[100010];

vi v;

vi G[200010];

int sum[100010];

Mod dp[200010];
bool used[200010];

bool ng[200010];

pi get_next( int p ){
  int it = lower_bound( s , s + n , s[p] + b ) - s;
  if( it == n ){
    return pi( n , SZ(v)-1 );
  }
  int d = upper_bound( ALL(v) , it ) - v.begin() - 1;
  return pi( it , d );
}

bool valid( int d , int nd ){
  assert( d < nd );
  return sum[nd] - sum[d+1] == ( nd - (d+1) );
}

void make_edge( int p , int d , int t ){
  pi res = get_next( p );
  if( res.se == d ){
    assert( res.fi == p + 1 );
    res.se++;
    res.fi++;
  }
  if( valid( d , res.se ) ){    
    if( res.fi == v[res.se] ){
      G[d*2+t].pb( res.se*2 );
      G[d*2+t].pb( res.se*2+1 );
    } else if( res.fi == v[res.se]+1 ){
      G[d*2+t].pb( res.se*2 );
    }
  }
}

Mod dfs( int x ){
  if( ng[x] ){
    return 0;
  }
  if( used[x] ){
    return dp[x];
  }
  used[x] = true;
  YYS( w , G[x] ){
    dp[x] += dfs( w );
  }
  return dp[x];
}

int naive(){
  int res = 0;
  REP( mask , PW(n) ){
    vi x(0);
    vi y(0);
    REP( i , n ){
      if( mask & PW(i) ){
        x.pb( s[i] );
      } else {
        y.pb( s[i] );
      }
    }
    bool ok = true;
    REP( i , SZ(x)-1 ){
      if( x[i+1] - x[i] < a ){
        ok = false;
      }
    }
    REP( i , SZ(y)-1 ){
      if( y[i+1] - y[i] < b ){
        ok = false;
      }
    }
    if( ok ){
      res++;
    }
  }
  return res;
}

int main(){

  n = in();
  a = in();
  b = in();
  REP( i , n ){
    s[i] = in();
  }

  if( a > b ){
    swap( a , b );
  }

  REP( i , n-2 ){
    if( s[i+2] - s[i] < a ){
      puts( "0" );
      return 0;
    }
  }

  v.pb( 0 );
  REP( i , n-1 ){
    if( s[i+1] - s[i] >= a ){
      v.pb( i+1 );
    }
  }
  v.pb( n );

  REP( i , SZ(v)-1 ){
    if( v[i+1] - v[i] == 1 ){
      sum[i+1] = sum[i] + 1;
    } else {
      sum[i+1] = sum[i];
    }
  }
  
  REP( i , SZ(v)-1 ){
    int len = v[i+1] - v[i];
    if( len == 1 ){
      G[i*2].pb( (i+1)*2 );
      G[i*2].pb( (i+1)*2 + 1 );
      make_edge( v[i] , i , 1 );
    } else {
      REP( j , 2 ){
        int k = ( j + len ) % 2;
        int c = v[i+1] - 1 - k;
        make_edge( c , i , j );
      }
    }
  }

  /*
  REP( i , SZ(v)*2-2 ){
    SHOWA( G[i] , SZ(G[i]) );
  }
  */

  REP( i , SZ(v)-1 ){
    int x = v[i];
    int y = v[i+1];
    REP( j , 2 ){
      for( int k = x + 1 - j; k + 2 < y; k += 2 ){
        if( s[k+2] - s[k] < b ){
          ng[i*2+j] = true;
        }
      }
    }
  }
  
  dp[SZ(v)*2-2] = 1;
  used[SZ(v)*2-2] = true;
  
  Mod ans = dfs( 0 ) + dfs( 1 );

  // assert( naive() == ans.n );

  printf( "%d\n" , (int)ans.n );

  return 0;
}


Measured memory_bytes: 18424