Problem: 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.

Examples

Input

5 3 7
1
3
6
9
12


Output

5


Input

7 5 3
0
2
4
7
8
11
15


Output

4


Input

8 2 9
3
4
5
13
15
22
26
32


Output

13


Input

3 3 4
5
6
7


Output

0

Solution (in PYTHON3):

Solution:
import sys
from bisect import bisect


class BinaryIndexedTree:

    def __init__(self, n, MOD):
        self.size = n + 1
        self.tree = [0] * (n + 2)
        self.MOD = MOD

    def sum(self, i):
        i += 1
        s = 0
        while i > 0:
            s = (s + self.tree[i]) % self.MOD
            i -= i & -i
        return s

    def add(self, i, x):
        i += 1
        while i <= self.size:
            self.tree[i] = (self.tree[i] + x) % self.MOD
            i += i & -i

    def debug_print(self, limit=None):
        if limit is None:
            limit = self.size
        acc = [0] + [self.sum(i) for i in range(limit)]
        aaa = [a1 - a0 for a0, a1 in zip(acc, acc[1:])]
        print(aaa)


def solve(n, a, b, sss):
    if a > b:
        a, b = b, a

    for s0, s2 in zip(sss, sss[2:]):
        if s2 - s0 < a:
            return 0

    MOD = 10 ** 9 + 7

    bit = BinaryIndexedTree(n, MOD)
    bit.add(0, 1)
    bit.add(1, 1)

    sss.insert(0, -10 ** 18 - 1)
    pos = 0

    for i in range(1, n):
        s0 = sss[i]
        s1 = sss[i + 1]
        lim = bisect(sss, s1 - b) - 1
        if lim >= pos:
            bit.add(i + 1, bit.sum(lim))
        if s1 - s0 < a:
            bit.add(i - 1, -bit.sum(i - 1))
            pos = i - 1

    return bit.sum(n)


n, a, b, *sss = map(int, sys.stdin.read().split())
print(solve(n, a, b, sss))