import typing

def _ceil_pow2(n: int) -> int:

    x = 0

    while (1 << x) < n:

        x += 1

    return x



class SegTree:

    def __init__(self,

                 op: typing.Callable[[typing.Any, typing.Any], typing.Any],

                 e: typing.Any,

                 v: typing.Union[int, typing.List[typing.Any]]):

        self._op = op

        self._e = e



        if isinstance(v, int):

            v = [e] * v



        self._n = len(v)

        self._log = _ceil_pow2(self._n)

        self._size = 1 << self._log

        self._d = [e] * (2 * self._size)



        for i in range(self._n):

            self._d[self._size + i] = v[i]

        for i in range(self._size - 1, 0, -1):

            self._update(i)

    

    def set(self, p: int, x: typing.Any) -> None:

        assert 0 <= p < self._n

        p += self._size

        self._d[p] = x

        for i in range(1, self._log + 1):

            self._update(p >> i)



    def get(self, p: int) -> typing.Any:

        assert 0 <= p < self._n

        return self._d[p + self._size]



    def prod(self, left: int, right: int) -> typing.Any:

        assert 0 <= left <= right <= self._n

        sml = self._e

        smr = self._e

        left += self._size

        right += self._size



        while left < right:

            if left & 1:

                sml = self._op(sml, self._d[left])

                left += 1

            if right & 1:

                right -= 1

                smr = self._op(self._d[right], smr)

            left >>= 1

            right >>= 1



        return self._op(sml, smr)



    def all_prod(self) -> typing.Any:

        return self._d[1]



    def max_right(self, left: int,

                  f: typing.Callable[[typing.Any], bool]) -> int:

        assert 0 <= left <= self._n

        assert f(self._e)



        if left == self._n:

            return self._n



        left += self._size

        sm = self._e



        first = True

        while first or (left & -left) != left:

            first = False

            while left % 2 == 0:

                left >>= 1

            if not f(self._op(sm, self._d[left])):

                while left < self._size:

                    left *= 2

                    if f(self._op(sm, self._d[left])):

                        sm = self._op(sm, self._d[left])

                        left += 1

                return left - self._size

            sm = self._op(sm, self._d[left])

            left += 1

        return self._n



    def min_left(self, right: int,

                 f: typing.Callable[[typing.Any], bool]) -> int:

        assert 0 <= right <= self._n

        assert f(self._e)



        if right == 0:

            return 0



        right += self._size

        sm = self._e



        first = True

        while first or (right & -right) != right:

            first = False

            right -= 1

            while right > 1 and right % 2:

                right >>= 1

            if not f(self._op(self._d[right], sm)):

                while right < self._size:

                    right = 2 * right + 1

                    if f(self._op(self._d[right], sm)):

                        sm = self._op(self._d[right], sm)

                        right -= 1

                return right + 1 - self._size

            sm = self._op(self._d[right], sm)



        return 0



    def _update(self, k: int) -> None:

        self._d[k] = self._op(self._d[2 * k], self._d[2 * k + 1])



N, K = list(map(int, input().split()))

A = list(int(eval(input())) for _ in range(N))

max_A = max(A)

seg = SegTree(max, 0, [0]*(max_A+1))

for v in A:

    l = max(0, v-K)

    r = min(max_A, v+K)

    seg.set(v, seg.prod(l, r+1)+1)

print((seg.all_prod()))
import typing

class SegTree:

    def _ceil_pow2(self, n: int) -> int:

        x = 0

        while (1 << x) < n:

            x += 1

        return x

    

    def __init__(self,

                 op: typing.Callable[[typing.Any, typing.Any], typing.Any],

                 e: typing.Any,

                 v: typing.Union[int, typing.List[typing.Any]]):

        self._op = op

        self._e = e



        if isinstance(v, int):

            v = [e] * v



        self._n = len(v)

        self._log = self._ceil_pow2(self._n)

        self._size = 1 << self._log

        self._d = [e] * (2 * self._size)



        for i in range(self._n):

            self._d[self._size + i] = v[i]

        for i in range(self._size - 1, 0, -1):

            self._update(i)

    

    def set(self, p: int, x: typing.Any) -> None:

        assert 0 <= p < self._n

        p += self._size

        self._d[p] = x

        for i in range(1, self._log + 1):

            self._update(p >> i)



    def prod(self, left: int, right: int) -> typing.Any:

        assert 0 <= left <= right <= self._n

        sml = self._e

        smr = self._e

        left += self._size

        right += self._size



        while left < right:

            if left & 1:

                sml = self._op(sml, self._d[left])

                left += 1

            if right & 1:

                right -= 1

                smr = self._op(self._d[right], smr)

            left >>= 1

            right >>= 1



        return self._op(sml, smr)



    def all_prod(self) -> typing.Any:

        return self._d[1]



    def _update(self, k: int) -> None:

        self._d[k] = self._op(self._d[2 * k], self._d[2 * k + 1])



N, K = list(map(int, input().split()))

A = list(int(eval(input())) for _ in range(N))

max_A = max(A)

seg = SegTree(max, -1, [0]*(max_A+1))

for v in A:

    l = max(0, v-K)

    r = min(max_A, v+K)

    seg.set(v, seg.prod(l, r+1)+1)

print((seg.all_prod()))
import typing


def _ceil_pow2(n: int) -> int:
    x = 0
    while (1 << x) < n:
        x += 1
    return x


class SegTree:
    def __init__(
        self,
        op: typing.Callable[[typing.Any, typing.Any], typing.Any],
        e: typing.Any,
        v: typing.Union[int, typing.List[typing.Any]],
    ):
        self._op = op
        self._e = e
        if isinstance(v, int):
            v = [e] * v
        self._n = len(v)
        self._log = _ceil_pow2(self._n)
        self._size = 1 << self._log
        self._d = [e] * (2 * self._size)
        for i in range(self._n):
            self._d[self._size + i] = v[i]
        for i in range(self._size - 1, 0, -1):
            self._update(i)

    def set(self, p: int, x: typing.Any) -> None:
        assert 0 <= p < self._n
        p += self._size
        self._d[p] = x
        for i in range(1, self._log + 1):
            self._update(p >> i)

    def get(self, p: int) -> typing.Any:
        assert 0 <= p < self._n
        return self._d[p + self._size]

    def prod(self, left: int, right: int) -> typing.Any:
        assert 0 <= left <= right <= self._n
        sml = self._e
        smr = self._e
        left += self._size
        right += self._size
        while left < right:
            if left & 1:
                sml = self._op(sml, self._d[left])
                left += 1
            if right & 1:
                right -= 1
                smr = self._op(self._d[right], smr)
            left >>= 1
            right >>= 1
        return self._op(sml, smr)

    def all_prod(self) -> typing.Any:
        return self._d[1]

    def max_right(self, left: int, f: typing.Callable[[typing.Any], bool]) -> int:
        assert 0 <= left <= self._n
        assert f(self._e)
        if left == self._n:
            return self._n
        left += self._size
        sm = self._e
        first = True
        while first or (left & -left) != left:
            first = False
            while left % 2 == 0:
                left >>= 1
            if not f(self._op(sm, self._d[left])):
                while left < self._size:
                    left *= 2
                    if f(self._op(sm, self._d[left])):
                        sm = self._op(sm, self._d[left])
                        left += 1
                return left - self._size
            sm = self._op(sm, self._d[left])
            left += 1
        return self._n

    def min_left(self, right: int, f: typing.Callable[[typing.Any], bool]) -> int:
        assert 0 <= right <= self._n
        assert f(self._e)
        if right == 0:
            return 0
        right += self._size
        sm = self._e
        first = True
        while first or (right & -right) != right:
            first = False
            right -= 1
            while right > 1 and right % 2:
                right >>= 1
            if not f(self._op(self._d[right], sm)):
                while right < self._size:
                    right = 2 * right + 1
                    if f(self._op(self._d[right], sm)):
                        sm = self._op(self._d[right], sm)
                        right -= 1
                return right + 1 - self._size
            sm = self._op(self._d[right], sm)
        return 0

    def _update(self, k: int) -> None:
        self._d[k] = self._op(self._d[2 * k], self._d[2 * k + 1])


N, K = list(map(int, input().split()))
A = list(int(eval(input())) for _ in range(N))
max_A = max(A)
seg = SegTree(max, 0, [0] * (max_A + 1))
for v in A:
    l = max(0, v - K)
    r = min(max_A, v + K)
    seg.set(v, seg.prod(l, r + 1) + 1)
print((seg.all_prod()))

import typing


class SegTree:
    def _ceil_pow2(self, n: int) -> int:
        x = 0
        while (1 << x) < n:
            x += 1
        return x

    def __init__(
        self,
        op: typing.Callable[[typing.Any, typing.Any], typing.Any],
        e: typing.Any,
        v: typing.Union[int, typing.List[typing.Any]],
    ):
        self._op = op
        self._e = e
        if isinstance(v, int):
            v = [e] * v
        self._n = len(v)
        self._log = self._ceil_pow2(self._n)
        self._size = 1 << self._log
        self._d = [e] * (2 * self._size)
        for i in range(self._n):
            self._d[self._size + i] = v[i]
        for i in range(self._size - 1, 0, -1):
            self._update(i)

    def set(self, p: int, x: typing.Any) -> None:
        assert 0 <= p < self._n
        p += self._size
        self._d[p] = x
        for i in range(1, self._log + 1):
            self._update(p >> i)

    def prod(self, left: int, right: int) -> typing.Any:
        assert 0 <= left <= right <= self._n
        sml = self._e
        smr = self._e
        left += self._size
        right += self._size
        while left < right:
            if left & 1:
                sml = self._op(sml, self._d[left])
                left += 1
            if right & 1:
                right -= 1
                smr = self._op(self._d[right], smr)
            left >>= 1
            right >>= 1
        return self._op(sml, smr)

    def all_prod(self) -> typing.Any:
        return self._d[1]

    def _update(self, k: int) -> None:
        self._d[k] = self._op(self._d[2 * k], self._d[2 * k + 1])


N, K = list(map(int, input().split()))
A = list(int(eval(input())) for _ in range(N))
max_A = max(A)
seg = SegTree(max, -1, [0] * (max_A + 1))
for v in A:
    l = max(0, v - K)
    r = min(max_A, v + K)
    seg.set(v, seg.prod(l, r + 1) + 1)
print((seg.all_prod()))

-def _ceil_pow2(n: int) -> int: -    x = 0 -    while (1 << x) < n: -        x += 1 -    return x +class SegTree: +    def _ceil_pow2(self, n: int) -> int: +        x = 0 +        while (1 << x) < n: +            x += 1 +        return x - -class SegTree: -        self._log = _ceil_pow2(self._n) +        self._log = self._ceil_pow2(self._n) - -    def get(self, p: int) -> typing.Any: -        assert 0 <= p < self._n -        return self._d[p + self._size] -    def max_right(self, left: int, f: typing.Callable[[typing.Any], bool]) -> int: -        assert 0 <= left <= self._n -        assert f(self._e) -        if left == self._n: -            return self._n -        left += self._size -        sm = self._e -        first = True -        while first or (left & -left) != left: -            first = False -            while left % 2 == 0: -                left >>= 1 -            if not f(self._op(sm, self._d[left])): -                while left < self._size: -                    left *= 2 -                    if f(self._op(sm, self._d[left])): -                        sm = self._op(sm, self._d[left]) -                        left += 1 -                return left - self._size -            sm = self._op(sm, self._d[left]) -            left += 1 -        return self._n - -    def min_left(self, right: int, f: typing.Callable[[typing.Any], bool]) -> int: -        assert 0 <= right <= self._n -        assert f(self._e) -        if right == 0: -            return 0 -        right += self._size -        sm = self._e -        first = True -        while first or (right & -right) != right: -            first = False -            right -= 1 -            while right > 1 and right % 2: -                right >>= 1 -            if not f(self._op(self._d[right], sm)): -                while right < self._size: -                    right = 2 * right + 1 -                    if f(self._op(self._d[right], sm)): -                        sm = self._op(self._d[right], sm) -                        right -= 1 -                return right + 1 - self._size -            sm = self._op(self._d[right], sm) -        return 0 - -seg = SegTree(max, 0, [0] * (max_A + 1)) +seg = SegTree(max, -1, [0] * (max_A + 1))