use whiteread::Reader;

fn main() {
    let mut rdr = Reader::from_stdin_naive();
    let (n, k): (usize, usize) = rdr.p();
    const SIZE: usize = 10;
    let mut st = data::SegmentTree::new(SIZE, 0, std::cmp::max);
    for _ in 0..n {
        let a: usize = rdr.p();
        let m = st.get(a.saturating_sub(k), a.saturating_add(k + 1)) + 1;
        st.set(a, m);
        //println!("{:?}", st);
    }
    println!("{}", st.get(0, SIZE));
}

mod data {
    pub struct SegmentTree<F, T> {
        size: usize,
        tree: Vec<T>,
        element: T,
        o: F,
    }

    impl<F, T> std::fmt::Debug for SegmentTree<F, T>
    where
        T: std::fmt::Debug,
    {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
            write!(f, "{:?}", self.tree)
        }
    }

    impl<F, T> SegmentTree<F, T>
    where
        F: Fn(T, T) -> T,
        T: Copy + Eq,
    {
        pub fn new(size: usize, element: T, o: F) -> Self {
            let size = size.next_power_of_two();
            Self {
                size,
                tree: vec![element; size * 2],
                element,
                o,
            }
        }

        /// get [a, b)
        pub fn get(&self, a: usize, b: usize) -> T {
            self._get(a, b, 1, 0, self.size)
        }

        fn _get(&self, a: usize, b: usize, k: usize, l: usize, r: usize) -> T {
            if r <= a || b <= l {
                self.element
            } else if a <= l && r <= b {
                self.tree[k]
            } else {
                (self.o)(
                    self._get(a, b, k * 2, l, (l + r) / 2),
                    self._get(a, b, k * 2 + 1, (l + r) / 2, r),
                )
            }
        }

        pub fn set(&mut self, index: usize, value: T) {
            let mut i = self.size + index;
            while i != 0 {
                let v = (self.o)(value, self.tree[i]);
                if v == self.tree[i] {
                    break;
                }
                self.tree[i] = v;
                i /= 2;
            }
        }
    }
}
