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

int ri() {
	int n;
	scanf("%d", &n);
	return n;
}
int64_t rs64() {
	int64_t n;
	scanf("%" SCNd64, &n);
	return n;
}
#define INF 1000000000000000000
struct SegTree {
	struct Node {
		int64_t sum = 0;
		int64_t min = INF;
		int min_cnt = 1;
		int64_t min2 = INF;
		int64_t max = -INF;
		int max_cnt = 1;
		int64_t max2 = -INF;
		int64_t add = 0;
		int64_t chmin = INF;
		int64_t chmax = -INF;
		int l;
		int r;
		Node () = default;
		Node (int64_t n) : sum(n), min(n), max(n) {}
	};
	int n;
	std::vector<Node> nodes;
	SegTree (const std::vector<int64_t> &a) {
		for (n = 1; n < (int) a.size(); n <<= 1);
		nodes.resize(n << 1);
		for (int i = 0; i < (int) a.size(); i++) nodes[i + n] = Node(a[i]);
		for (int i = 0; i < n; i++) nodes[i + n].l = i, nodes[i + n].r = i + 1;
		for (int i = n; --i; ) fetch(i);
	}
	void fetch(int i) {
		Node &node = nodes[i];
		const Node &l = nodes[i << 1];
		const Node &r = nodes[i << 1 | 1];
		node.sum = l.sum + r.sum;
		if (l.min < r.min) node.min = l.min, node.min_cnt = l.min_cnt, node.min2 = std::min(l.min2, r.min);
		else if (l.min > r.min) node.min = r.min, node.min_cnt = r.min_cnt, node.min2 = std::min(l.min, r.min2);
		else node.min = l.min, node.min_cnt = l.min_cnt + r.min_cnt, node.min2 = std::min(l.min2, r.min2);
		if (l.max > r.max) node.max = l.max, node.max_cnt = l.max_cnt, node.max2 = std::max(l.max2, r.max);
		else if (l.max < r.max) node.max = r.max, node.max_cnt = r.max_cnt, node.max2 = std::max(l.max, r.max2);
		else node.max = l.max, node.max_cnt = l.max_cnt + r.max_cnt, node.max2 = std::max(l.max2, r.max2);
		node.l = l.l;
		node.r = r.r;
	}
	void flush(int i) {
		Node &node = nodes[i];
		if (node.add) {
			node.sum += (node.r - node.l) * node.add;
			node.min += node.add;
			node.max += node.add;
			if (node.min2 != INF) node.min2 += node.add;
			if (node.max2 != -INF) node.max2 += node.add;
			if (i < n) {
				nodes[i << 1].add += node.add;
				nodes[i << 1 | 1].add += node.add;
				if (nodes[i << 1].chmin != INF) nodes[i << 1].chmin += node.add;
				if (nodes[i << 1 | 1].chmin != INF) nodes[i << 1 | 1].chmin += node.add;
				if (nodes[i << 1].chmax != -INF) nodes[i << 1].chmax += node.add;
				if (nodes[i << 1 | 1].chmax != -INF) nodes[i << 1 | 1].chmax += node.add;
			}
			node.add = 0;
		}
		if (node.chmin != INF) {
			if (i < n) {
				nodes[i << 1].chmin = std::min(nodes[i << 1].chmin, node.chmin);
				nodes[i << 1 | 1].chmin = std::min(nodes[i << 1 | 1].chmin, node.chmin);
				nodes[i << 1].chmax = std::min(nodes[i << 1].chmax, node.chmin);
				nodes[i << 1 | 1].chmax = std::min(nodes[i << 1 | 1].chmax, node.chmin);
			}
			if (node.chmin < node.max2) {
				flush(i << 1);
				flush(i << 1 | 1);
				fetch(i);
			} else if (node.chmin < node.max) {
				node.sum -= (node.max - node.chmin) * node.max_cnt;
				if (node.min == node.max) node.min = node.chmin;
				else node.min2 = std::min(node.min2, node.chmin);
				node.max = node.chmin;
			}
			node.chmin = INF;
		}
		if (node.chmax != -INF) {
			if (i < n) {
				nodes[i << 1].chmax = std::max(nodes[i << 1].chmax, node.chmax);
				nodes[i << 1 | 1].chmax = std::max(nodes[i << 1 | 1].chmax, node.chmax);
			}
			if (node.chmax > node.min2) {
				flush(i << 1);
				flush(i << 1 | 1);
				fetch(i);
			} else if (node.chmax > node.min) {
				node.sum += (node.chmax - node.min) * node.min_cnt;
				if (node.max == node.min) node.max = node.chmax;
				else node.max2 = std::max(node.max2, node.chmax);
				node.min = node.chmax;
			}
			node.chmax = -INF;
		}
	}
	template<class T> void update(int l, int r, const T &func, int node_id) {
		Node &node = nodes[node_id];
		flush(node_id);
		if (r <= node.l || l >= node.r) return;
		if (l <= node.l && r >= node.r) {
			func(node);
			flush(node_id);
		} else {
			update(l, r, func, node_id << 1);
			update(l, r, func, node_id << 1 | 1);
			fetch(node_id);
		}
	}
	void add(int l, int r, int64_t val) {
		update(l, r, [&] (Node &node) { node.add = val; }, 1);
	}
	void chmin(int l, int r, int64_t val) {
		update(l, r, [&] (Node &node) { node.chmin = val; }, 1);
	}
	void chmax(int l, int r, int64_t val) {
		update(l, r, [&] (Node &node) { node.chmax = val; }, 1);
	}
	int64_t sum(int l, int r, int node_id = 1) {
		Node &node = nodes[node_id];
		flush(node_id);
		if (r <= node.l || l >= node.r) return 0;
		if (l <= node.l && r >= node.r) return node.sum;
		int64_t res =
			sum(l, r, node_id << 1) +
			sum(l, r, node_id << 1 | 1);
		fetch(node_id);
		return res;
	}
};

int main(){
	int n,k; cin >> n >> k;
	vector<int> a(n);
	for(int i=0;i<n;i++){
		cin >> a[i];
	}
	vector<int> dp(n,1);
	vector<int64_t> rui(300300,1);
	SegTree seg(rui);
	for(int i=0;i<n;i++){
		dp[i]=seg.sum(a[i],a[i]+1);
		seg.chmax(max(a[i]-k,0),min(a[i]+k+1,300300),dp[i]+1);
	}
	int res=0;
	for(int i=0;i<n;i++){
		res=max(res,dp[i]);
	}
	cout << res << endl;
}

Measured memory_bytes: 98052