#include<iostream>
#include<vector>
#include<queue>
#include <cmath>

using namespace std;
typedef long long int ll;

template<typename T>
class SegmentTree
{

    /*
    調整するパラメータ
        1. update_tree関数: セグメント木に何を記憶されるかが決定される。現在はmin
        2. minなのでInitialValueは非常に大きな値にしている
        3. demand関数

    こちらで使用する関数
    update(int kth, int value_new): kth番目の要素及びツリーを更新: update_element, update_treeを呼ぶ
    demand(int start, int end, )

    */
    T InitialValue;

    const int N; // Nは2のべき
    int m_N_array;
    T *values = new T[2*N-1]; // tree structure, index=[0, N-2]->tree, [N-1, 2N-2]->要素の中身

    /*
    0
    1 2
    3 4 5 6
    7 8 9 10 11 12 13 14
    ...
    N/2-1 ... N-2 (ここまでtree)

    N-1 ... 2N-2  (要素の中身, kth+N-1の値を更新)

    親は(index-1)/2
    子はindex*2+1, index*2+2
    */
public:
    SegmentTree(const int N_in, T InitialValue_in): N( std::pow(2, std::ceil( std::log( std::max(N_in, 1) )/std::log(2) ) ) )
    {
        /*
        要素数は2のべき乗にする。N_inより大きい2のべきの数をNにいれる。Nの最低値は1
        例えばN_in = 10ならN=16を割り当てる
        */
        InitialValue = InitialValue_in;
        m_N_array = 2*N-1;
        for(int i=0; i<m_N_array; i++)
        {
            values[i] = InitialValue;
        }
    };

    virtual ~SegmentTree()
    {
        delete[] values;
        values = NULL;
    };

    void update_element(int kth, T value_new)
    {
        // substitute value_new in k-th element (kth =0, 1, ..., N-1)
        // values-> tree structure, index=[0, N-2]->tree, [N-1, 2N-2]->要素の中身
        values[kth+N-1] = value_new;
    }

    void update_tree(int kth, T value_new)
    {
        // substitute value_new in k-th element (kth =0, 1, ..., N-1)
        // values-> tree structure, index=[0, N-2]->tree, [N-1, 2N-2]->要素の中身
        // ここではminを記録
        /*
        0
        1 2
        3 4 5 6
        7 8 9 10 11 12 13 14
        ...
        N/2-1 ... N-2 (ここまでtree)

        N-1 ... 2N-2  (要素の中身, kth+N-1の値を更新)

        親は(index-1)/2
        子はindex*2+1, index*2+2
        */
        int index = kth+N-1;
        int par = (index-1)/2;
        while(index>0)
        {
            values[par] = std::max(values[par], values[index]); // ここを変更
            index = par;
            par = (index-1)/2;
        }

    }

    void update(int kth, T value_new)
    {
        // substitute value_new in k-th element (kth =0, 1, ..., N-1)
        // values-> tree structure, index=[0, N-2]->tree, [N-1, 2N-2]->要素の中身
        update_element(kth, value_new);
        // ツリー構造の更新
        update_tree(kth, value_new);

    }

    T demand(int start, int end, int id_array=0, int left=0, int right = -1)
    {
        /*
        [start, end]の範囲から求める値を返してもらう。初期はminを返す
        現在はvalues[id_array]を調べている。その子供の範囲が[left, right]


        0
        1 2
        3 4 5 6
        7 8 9 10 11 12 13 14
        [0, 6]-> N=8, 7-13を調べる -> 1と5と13
        */
        if(right < 0) right += N;
        // std::cout << id_array << " " << left << ", " << right << std::endl;

        if(right < start || left > end){
            // 1. 範囲外
            return InitialValue;
        }
        else if(start <= left && end >= right)
        {
            // 2. 全領域が含まれる
            return values[id_array];
        }
        else
        {
            // 3.部分的に含まれる -> 子供を見る
            // [left, mid]と[mid+1, right]に分割
            int mid = (left+right)/2;
            T value_left = demand(start, end, 2*id_array+1, left, mid);
            T value_right = demand(start, end, 2*id_array+2, mid+1, right);
            return std::max(value_left, value_right);
        }


    }

    void show()
    {
        for(int i=0; i<N; i++)
        {
            std::cout << values[N-1+i] << " ";
        }
        std::cout << std::endl;
    }



};
typedef SegmentTree<int> SegmentTree_int;
typedef SegmentTree<double> SegmentTree_double;



int main(void){
  ll a, b;
  cin >> a >> b;

  SegmentTree<ll> Seg(300000, 0);
  vector<int> array(a);
  int N = a;
  int K = b;
  for(int i=0; i<N; i++)
  {
    cin >>array[i];
  }
  Seg.update(array[0], 1);
  for(int i=1; i<N; i++)
  {
    int v = Seg.demand( max(0, array[i]-K), min(300000, array[i]+K) );

    Seg.update(array[i], v+1);
  }

  cout << Seg.demand(0, 300000) << endl;
  return 0;
}


Measured memory_bytes: 12776