#include <bits/stdc++.h>
using namespace std;

//入力
template<typename T>
istream& operator>>(istream& is,vector<T>& a){
    for(size_t i=0;i<a.size();i++)is>>a[i];
    return is;
}
template<typename T,typename U>
istream& operator>>(istream& is,pair<T,U>& p){
    is>>p.first>>p.second;
    return is;
}

//出力
template<typename T>
ostream& operator<<(ostream& os,const vector<T>& a){
    for(int i=0;i<a.size();i++){
        os<<a[i]<<((i+1!=a.size())?" ":"");
    }
    return os;
}
template<typename T,typename U>
ostream& operator<<(ostream& os,const pair<T,U>& p){
    os<<p.first<<" "<<p.second;
    return os;
}

//入出力高速化
struct hishimochi{
    hishimochi(){
        ios::sync_with_stdio(false);
        cin.tie(nullptr);
        cout<<fixed<<setprecision(10);
    }
};
hishimochi Hishimochi;

//多次元配列
template<class T>
vector<T> make_vec(size_t a){
    return vector<T>(a);
}
template<class T,class... Ts>
auto make_vec(size_t a,Ts... ts){
    return vector<decltype(make_vec<T>(ts...))>(a,make_vec<T>(ts...));
}

//辺
struct edge{
    long long to,cost;
    edge(long long t,long long c):to(t),cost(c){}
};
struct edge2{
    long long from,to,cost;
    edge2(long long f,long long t,long long c):from(f),to(t),cost(c){}
};

//型名
using ll=long long;
using ull=unsigned long long;
using ld=long double;
using pll=pair<long long,long long>;
using vl=vector<long long>;
using vvl=vector<vector<long long>>;
using vvvl=vector<vector<vector<long long>>>;
using vi=vector<int>;
using vvi=vector<vector<int>>;
using vvvi=vector<vector<vector<int>>>;
using vc=vector<char>;
using vvc=vector<vector<char>>;
using vs=vector<string>;
using vb=vector<bool>;
using vvb=vector<vector<bool>>;
using vp=vector<pair<long long,long long>>;
using Lqueue=priority_queue<long long>;
using Squeue=priority_queue<long long,vector<long long>,greater<long long>>;

//定数
const int MOD1=1000000007;
const int MOD2=998244353;
const long double PI=3.1415926535897932;
const long long MAXLL=9223372036854775807;
const int MAXI=2147483647;
const long long INF=2305843009213693951;
const int inf=1073741789;
const long double eps=0.000000001;
const int dx[]={0,1,0,-1,1,-1,1,-1};
const int dy[]={1,0,-1,0,1,1,-1,-1};

//マクロ
#define overload3(_1,_2,_3,name,...) name
#define rep1(n) for(int _=0;_<(n);_++)
#define rep2(i,n) for(int i=0;i<(n);i++)
#define rep3(i,s,n) for(long long i=(s);i<(n);i++)
#define rep(...) overload3(__VA_ARGS__,rep3,rep2,rep1)(__VA_ARGS__)
#define bitrep1(n) for(int _=0;_<(1LL<<(n));_++)
#define bitrep2(i,n) for(int i=0;i<(1LL<<(n));i++)
#define bitrep3(i,s,n) for(int i=(s);i<(1LL<<(n));i++)
#define bitrep(...) overload3(__VA_ARGS__,bitrep3,bitrep2,bitrep1)(__VA_ARGS__)
#define rrep0(n) for(int i=(n)-1;i>=0;i--)
#define rrep1(i,n) for(int i=(n)-1;i>=0;i--)
#define rrep2(i,s,n) for(long long i=(n-1);i>=(s);i--)
#define rrep(...) overload3(__VA_ARGS__,rrep2,rrep1,rrep0)(__VA_ARGS__)
#define rbf(a,x) for(auto& a:x)
#define all(x) (x).begin(),(x).end()
#define rall(x) (x).rbegin(),(x).rend()
#define bitcheck(bit,i) (bit)&(1LL<<(i))
#define Maxe(x) *max_element((x).begin(),(x).end())
#define Mine(x) *min_element((x).begin(),(x).end())
#define Sume(x) accumulate((x).begin(),(x).end(),0LL)
#define Size(x) ((long long)(x).size())
#define Sort(x) sort((x).begin(),(x).end())
#define rSort(x) sort((x).rbegin(),(x).rend())
#define Rev(x) reverse((x).begin(),(x).end())
#define Lin(s) getline(cin,(s))

//省略
#define fi first
#define se second
#define mp make_pair
#define mt make_tuple
#define eb emplace_back

//関数
void Yes(bool a){cout<<(a?"Yes":"No")<<endl;}
void YES(bool a){cout<<(a?"YES":"NO")<<endl;}
long long modpow(long long x,long long n,int m){long long r=1;while(n>0){if(n&1)(r*=x)%=m;(x*=x)%=m;n>>=1;}return r;}
long long Gcd(long long a,long long b){return b?Gcd(b,a%b):a;}
long long Lcm(long long a,long long b){return a/Gcd(a,b)*b;}
inline long long cutup(long long a,long long b){return (a+b-1)/b;}
inline long long popcnt(long long a){return __builtin_popcountll(a);}
template<class T,class U> auto max(T a,U b){return a>b?a:b;}
template<class T,class U> auto min(T a,U b){return a<b?a:b;}
template<class T,class U> inline bool chmin(T& a,U b){if(a>b){a=b;return true;}return false;}
template<class T,class U> inline bool chmax(T& a,U b){if(a<b){a=b;return true;}return false;}
template<class T> void print(T a){cout<<a<<"\n";}
template<class t> t mypow(t a,long long b){if(b==0)return 1;if(a==0)return 0;t x=1;while(b>0){if(b&1LL)x*=a;a*=a;b>>=1LL;}return x;}

//Segtree
//O(n)
//op 二項演算
//e 単位元
template<class S,S (*op)(S,S),S(*e)()>struct segtree{
    int _n,size,log;
    vector<S> d;
    int ceil_pow2(int n){
        int x=0;
        while((1U<<x)<(unsigned int)(n))x++;
        return x;
    }
    segtree():segtree(0){}
    segtree(int n):segtree(vector<S>(n,e())){}
    segtree(const vector<S>& v):_n(int(v.size())){
        log=ceil_pow2(_n);
        size=1<<log;
        d=vector<S>(2*size,e());
        for(int i=0;i<_n;i++)d[size+i]=v[i];
        for(int i=size-1;i>=1;i--){
            update(i);
        }
    }
    //a[p]にxを代入する
    //O(logn)
    void set(int p,S x){
        assert(0<=p&&p<_n);
        p+=size;
        d[p]=x;
        for(int i=1;i<=log;i++)update(p>>i);
    }
    //a[p]を返す
    //O(1)
    S get(int p){
        assert(0<=p&&p<_n);
        return d[p+size];
    }
    //op[l,r)を返す
    //O(logn)
    S prod(int l,int r){
        assert(0<=l&&l<=r&&r<=_n);
        S sml=e(),smr=e();
        l+=size;
        r+=size;
        while(l<r){
            if(l&1)sml=op(sml,d[l++]);
            if(r&1)smr=op(d[--r],smr);
            l>>=1;
            r>>=1;
        }
        return op(sml,smr);
    }
    //op[0,n)を返す
    //n=0ではe()を返す
    //O(1)
    S all_prod(){return d[1];}
    //二分探索
    template<bool (*f)(S)>int max_right(int l){
        return max_right(l,[](S x){return f(x);});
    }
    template<class F>int max_right(int l,F f){
        assert(0<=l&&l<=_n);
        assert(f(e()));
        if(l==_n)return _n;
        l+=size;
        S sm=e();
        do{
            while(l%2==0)l>>=1;
            if(!f(op(sm,d[l]))){
                while(l<size){
                    l=(2*l);
                    if(f(op(sm,d[l]))){
                        sm=op(sm,d[l]);
                        l++;
                    }
                }
                return l-size;
            }
            sm=op(sm,d[l]);
            l++;
        }while((l&-l)!=l);
        return _n;
    }
    template<bool (*f)(S)>int min_left(int r){
        return min_left(r,[](S x){return f(x);});
    }
    template<class F>int min_left(int r,F f){
        assert(0<=r&&r<=_n);
        assert(f(e()));
        if(r==0)return 0;
        r+=size;
        S sm=e();
        do{
            r--;
            while(r>1&&(r%2))r>>=1;
            if(!f(op(d[r],sm))){
                while(r<size){
                    r=(2*r+1);
                    if(f(op(d[r],sm))){
                        sm=op(d[r],sm);
                        r--;
                    }
                }
                return r+1-size;
            }
            sm=op(d[r],sm);
        }while((r&-r)!=r);
        return 0;
    }
    void update(int k){d[k]=op(d[2*k],d[2*k+1]);}
};

ll op(ll a,ll b){
    return max(a,b);
}

ll e(){
    return 0LL;
}

signed main(){
    ll n,k;
    cin>>n>>k;
    vl A(n);
    rep(i,n)cin>>A[i];
    ll m=Maxe(A);
    segtree<ll,op,e> S(m+5);
    ll res=0;
    rep(i,n){
        ll l=max(0,A[n-1-i]-1-k);
        ll r=min(m,A[n-1-i]+k);
        ll p=S.prod(l,r);
        chmax(res,p+1);
        S.set(A[n-1-i]-1,p+1);
    }
    print(res);
}
