package main

import (
	"bufio"
	"fmt"
	"os"
	"sort"
)

type Point struct {
	u, v int
}

type SegTree struct {
	n    int
	tree []int
	lazy []int
}

func NewSegTree(n int) *SegTree {
	return &SegTree{
		n:    n,
		tree: make([]int, 4*n),
		lazy: make([]int, 4*n),
	}
}

func (s *SegTree) push(node int) {
	if s.lazy[node] != 0 {
		s.tree[node*2] += s.lazy[node]
		s.lazy[node*2] += s.lazy[node]
		s.tree[node*2+1] += s.lazy[node]
		s.lazy[node*2+1] += s.lazy[node]
		s.lazy[node] = 0
	}
}

func (s *SegTree) pull(node int) {
	if s.tree[node*2] > s.tree[node*2+1] {
		s.tree[node] = s.tree[node*2]
	} else {
		s.tree[node] = s.tree[node*2+1]
	}
}

func (s *SegTree) update(node, l, r, ql, qr, val int) {
	if ql > r || qr < l {
		return
	}
	if ql <= l && r <= qr {
		s.tree[node] += val
		s.lazy[node] += val
		return
	}
	s.push(node)
	mid := (l + r) / 2
	s.update(node*2, l, mid, ql, qr, val)
	s.update(node*2+1, mid+1, r, ql, qr, val)
	s.pull(node)
}

func main() {
	reader := bufio.NewReader(os.Stdin)
	writer := bufio.NewWriter(os.Stdout)
	defer writer.Flush()

	var n, r int
	fmt.Fscan(reader, &n, &r)

	points := make([]Point, n)
	vs := make([]int, n)

	for i := 0; i < n; i++ {
		var x, y int
		fmt.Fscan(reader, &x, &y)
		u := x + y
		v := x - y
		points[i] = Point{u, v}
		vs[i] = v
	}

	sort.Ints(vs)
	m := 0
	for i := 0; i < n; i++ {
		if i == 0 || vs[i] != vs[i-1] {
			vs[m] = vs[i]
			m++
		}
	}
	vs = vs[:m]

	comp := make(map[int]int, m)
	for i := 0; i < m; i++ {
		comp[vs[i]] = i
	}

	rIdx := make([]int, m)
	limit := 2 * r
	for i := 0; i < m; i++ {
		target := vs[i] + limit
		idx := sort.Search(m, func(j int) bool { return vs[j] > target })
		rIdx[i] = idx - 1
	}

	sort.Slice(points, func(i, j int) bool {
		return points[i].u < points[j].u
	})

	st := NewSegTree(m)
	ans := 0
	left := 0

	for right := 0; right < n; right++ {
		idx := comp[points[right].v]
		l := sort.Search(m, func(i int) bool { return rIdx[i] >= idx })
		st.update(1, 0, m-1, l, idx, 1)

		for points[right].u-points[left].u > limit {
			idxLeft := comp[points[left].v]
			lLeft := sort.Search(m, func(i int) bool { return rIdx[i] >= idxLeft })
			st.update(1, 0, m-1, lLeft, idxLeft, -1)
			left++
		}

		if st.tree[1] > ans {
			ans = st.tree[1]
		}
	}

	fmt.Fprintln(writer, ans)
}