import java.util.*;
import java.util.function.BinaryOperator;
import java.util.function.UnaryOperator;

public class Main {
    public static void main(String[] args) throws Exception {
        // Your code here!
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int k = sc.nextInt();
        int[] array = new int[n];
        for (int i = 0; i < n; i++) {
            array[i] = sc.nextInt();
        }
        
        List<Integer> list = new ArrayList<Integer>();
        
        boolean[] ok = new boolean[300001];
        Arrays.fill(ok, true);
        for (int i = 0; i < n; i++) {
            int num = array[i];
            if (ok[num]) {
                list.add(i);
                ok[num] = false;
                
                for (int j = num+1; j <= num+k; j++) {
                    if (j >= 300001) break;
                    if (ok[j]) {
                        ok[j] = false;
                    } else {
                        break;
                    }
                }
                
                for (int j = num-1; j >= num-k; j--) {
                    if (j < 0) break;
                    if (ok[j]) {
                        ok[j] = false;
                    } else {
                        break;
                    }
                }
            }
            
            // System.out.println(Arrays.toString(ok));
        }
        // System.out.println(list.toString());
        
        int ans = 0;
        for (Integer i : list) {
            int tmp = 0;
            int now = array[i];
            for (int j = i; j < n; j++) {
                if (Math.abs(now - array[j]) <= k) {
                    tmp++;
                    now = array[j];
                }
            }
            
            ans = Math.max(ans, tmp);
        }
        System.out.println(ans);
        
        // SegmentTree<Long> maxseg = new SegmentTree<>(n, Long::sum, 0L);
        
        // // 初期の配列を取得
        // for (int i = 0; i < n; i++) {
        //     seg.update(i, sc.nextLong());
        // }
        
        // while (q-- > 0) {
        //     int type = sc.nextInt();
            
        //     if (type == 0) {
        //         // 一点加算
        //         int p = sc.nextInt();
        //         long x = sc.nextInt();
                
        //         long now = seg.query(p, p+1);
        //         seg.update(p, now + x);
        //     } else {
        //         // 区間取得
        //         int l = sc.nextInt();
        //         int r = sc.nextInt();
        //         long res = seg.query(l, r);
        //         System.out.println(res);
        //     }
        // }
    }
}

class SegmentTree<T> {
    // dat: 0-indexed
    // 00000000
    // 11112222
    // 33445566
    // 789ABCDE ... a[0]-a[n]
    
    final T[] dat;              // データを格納する配列
    final int n;                // datの一番下のレベルの要素数
    final BinaryOperator<T> f;  // 二項演算子
    final T e;                  // 単位元

    // 単位元で埋めて新規作成
    public SegmentTree(int len, BinaryOperator<T> f, T e) {
        int n = 1;
        while (n < len) n <<= 1;
        this.n = n;
        this.f = f;
        this.e = e;
        this.dat = (T[]) new Object[n << 1];
        Arrays.fill(dat, e);
    }
    
    // 一点更新(a[i] = x) O(logN)
    public void update(int i, T x) {
        i += n - 1;
        dat[i] = x;
        while (i > 0) {
            i = (i - 1) / 2;  // i: parent of vl/vr
            T vl = dat[i * 2 + 1];
            T vr = dat[i * 2 + 2];
            dat[i] = f.apply(vl, vr);
        }
    }
    
    // 区間取得[a, b) O(logN)
    public T query(int a, int b) { return query_sub(a, b, 0, 0, n); }
    public T query_sub(int a, int b, int k, int l, int r) {
        if (r <= a || b <= l) {             // outside completely
            return e;
        } else if (a <= l && r <= b) {      // inside completely
            return dat[k];
        } else {
            T vl = query_sub(a, b, k * 2 + 1, l, (l + r) / 2);
            T vr = query_sub(a, b, k * 2 + 2, (l + r) / 2, r);
            return f.apply(vl, vr);
        }
    }
    
    // 使用例
    // Range Sum Query
    // SegmentTree<Integer> seg = new SegmentTree<>(n, Integer::sum, 0);
    // SegmentTree<Long> seg = new SegmentTree<>(n, Long::sum, 0L);
    
    // Range Minimum Query
    // SegmentTree<Integer> seg = new SegmentTree<>(n, Integer::min, Integer.MAX_VALUE);
    
    // Range Maximum Query
    // SegmentTree<Long> seg = new SegmentTree<>(n, Long::max, Long.MIN_VALUE);
}