Problem:
Score : 1100 points

Problem Statement

There is a set consisting of N distinct integers. The i-th smallest element in this set is S_i. We want to divide this set into two sets, X and Y, such that:

The absolute difference of any two distinct elements in X is A or greater.

The absolute difference of any two distinct elements in Y is B or greater.

How many ways are there to perform such division, modulo 10^9 + 7? Note that one of X and Y may be empty.

Constraints

All input values are integers.

1 ≦ N ≦ 10^5

1 ≦ A , B ≦ 10^{18}

0 ≦ S_i ≦ 10^{18}(1 ≦ i ≦ N)

S_i < S_{i+1}(1 ≦ i ≦ N - 1)

Input

The input is given from Standard Input in the following format:

N A B
S_1
:
S_N

Output

Print the number of the different divisions under the conditions, modulo 10^9 + 7.

Sample Input 1

5 3 7
1
3
6
9
12

Sample Output 1

5

There are five ways to perform division:

X={1,6,9,12}, Y={3}

X={1,6,9}, Y={3,12}

X={3,6,9,12}, Y={1}

X={3,6,9}, Y={1,12}

X={3,6,12}, Y={1,9}

Sample Input 2

7 5 3
0
2
4
7
8
11
15

Sample Output 2

4

Sample Input 3

8 2 9
3
4
5
13
15
22
26
32

Sample Output 3

13

Sample Input 4

3 3 4
5
6
7

Sample Output 4

0

Solution in Ruby (2.3.3) (judge verdict: Accepted)

class BIT
    def initialize(n)
        @n = n+1
        @dat = Array.new(@n+1, 0)
    end

    def sum(i)
        s = 0
        while i >= 0 do
            s = (s + @dat[i]) % MOD
            i = (i & (i + 1)) - 1
        end
        s
    end

    def sum_between(a, b)
        b >= a ? (sum(b) - sum(a-1)) % MOD : 0
    end

    def add(i, x)
        while i <= @n do
            @dat[i] = (@dat[i] + x) % MOD
            i |= i + 1
        end
    end
end

MOD = 10**9+7

N, A, B = gets.split.map(&:to_i)
S = [-10**20] + N.times.map{gets.to_i}

left_A = Array.new(N+1)
left_B = Array.new(N+1)
la, lb = -1, -1
(1..N).each do |r|
    la += 1 while S[r] - S[la+1] >= A
    lb += 1 while S[r] - S[lb+1] >= B
    left_A[r] = la
    left_B[r] = lb
end

dpA = BIT.new(N+1)
dpB = BIT.new(N+1)
dpA.add(0, 1)
dpB.add(0, 1)

la, lb = 0, 0
(2..N).each do |i|
    addA = dpB.sum_between(lb, left_A[i])
    addB = dpA.sum_between(la, left_B[i])
    dpA.add(i-1, addA)
    dpB.add(i-1, addB)
    la = i-1 if left_A[i] != i-1
    lb = i-1 if left_B[i] != i-1
end
puts (dpA.sum_between(la, N-1) + dpB.sum_between(lb, N-1)) % MOD