### BUGGY CODE ###

import sys

sys.setrecursionlimit(10 ** 5)
input = lambda: sys.stdin.readline()


def scc(G):
    N = len(G)
    RG = [[] for _ in range(N)]

    for i, e in enumerate(G):
        for v in e:
            RG[v].append(i)

    order = []
    used = [0] * (N + 1)
    group = [None] * (N + 1)

    def dfs(s):
        used[s] = 1
        for t in G[s]:
            if not used[t]:
                dfs(t)
        order.append(s)

    def rdfs(s, col):
        group[s] = col
        used[s] = 1
        for t in RG[s]:
            if not used[t]:
                rdfs(t, col)

    for i in range(N):
        if not used[i]:
            dfs(i)

    used = [0] * (N + 1)
    label = 0

    for s in reversed(order):
        if not used[s]:
            rdfs(s, label)
            label += 1

    G0 = [set() for _ in range(label)]
    GP = [[] for _ in range(label)]

    for v in range(N):
        lbs = group[v]
        for w in G[v]:
            lbt = group[w]
            if lbs == lbt:
                continue
            G0[lbs].add(lbt)
        GP[lbs].append(v)
    return group, GP


class twosat():
    def __init__(self, n):
        self.n = n
        self.E = [[] for _ in range(n * 2)]

    def sat(self):
        group, GP = scc(self.E)
        re = [0] * self.n
        for i in range(self.n):
            if group[2 * i] == group[2 * i + 1]:
                return (0, [])
            if group[2 * i] < group[2 * i + 1]:
                re[i] = 1
        return (1, re)


n, d = map(int, input().split())
ts = twosat(n)
G = []
for _ in range(n):
    x = int(input())
    G.append(x)

for i, x1 in enumerate(G):
    for j, x2 in enumerate(G[:i]):
        if abs(x1 - x2) < d:
            ts.E[i * 2 + (1 ^ 1)].append(j * 2 + 1)
            ts.E[j * 2 + (1 ^ 1)].append(i * 2 + 1)

flg, re = ts.sat()
print(sum(re))


### FIXED CODE ###

import sys
import numpy as np


def solve(inp):
    def bit_length(x):
        ret = 0
        while x:
            x >>= 1
            ret += 1
        return ret

    n = 300001
    ide_ele = 0
    num = 1 << bit_length(n)
    seg = [ide_ele] * 2 * num

    def segfunc(x, y):
        return max(x, y)

    def init(init_arr):
        for i in range(n):
            seg[i + num - 1] = init_arr[i]
        for i in range(num - 2, -1, -1):
            seg[i] = segfunc(seg[2 * i + 1], seg[2 * i + 2])


    def update(k, x):
        k += num - 1
        seg[k] = x
        while k:
            k = (k - 1) // 2
            seg[k] = segfunc(seg[k * 2 + 1], seg[k * 2 + 2])


    def query(p, q):
        if q <= p:
            return ide_ele
        p += num - 1
        q += num - 2
        res = ide_ele
        while q - p > 1:
            if p & 1 == 0:
                res = segfunc(res, seg[p])
            if q & 1 == 1:
                res = segfunc(res, seg[q])
                q -= 1
            p = p // 2
            q = (q - 1) // 2
        if p == q:
            res = segfunc(res, seg[p])
        else:
            res = segfunc(segfunc(res, seg[p]), seg[q])
        return res


    N = inp[0]
    d = inp[1]
    A = inp[2:]
    arr = np.zeros(n, dtype=np.int64)
    init(arr)

    for a in A:
        l = max(0, a - d)
        r = min(a + d + 1, n)
        v = query(l, r)
        update(a, v + 1)
    return query(0, n)


if sys.argv[-1] == 'ONLINE_JUDGE':
    from numba.pycc import CC

    cc = CC('my_module')
    cc.export('solve', '(i8[:],)')(solve)
    cc.compile()
    exit()

from my_module import solve

inp = np.fromstring(sys.stdin.read(), dtype=np.int64, sep=' ')
ans = solve(inp)
print(ans)