package main

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

const INF int64 = 9223372036854775807

type Item struct {
	m  int64
	s  int64
	p  int64
	rr int64
}

type Cap struct {
	p  int64
	rr int64
}

var items []Item
var masses []int64
var start []int
var end []int
var ptr []int
var seg []int64
var queue []Cap
var ans int

func nextInt64(data []byte, idx *int) int64 {
	for *idx < len(data) && data[*idx] <= ' ' {
		(*idx)++
	}
	sign := int64(1)
	if data[*idx] == '-' {
		sign = -1
		(*idx)++
	}
	var v int64
	for *idx < len(data) && data[*idx] >= '0' && data[*idx] <= '9' {
		v = v*10 + int64(data[*idx]-'0')
		(*idx)++
	}
	return v * sign
}

func min64(a, b int64) int64 {
	if a < b {
		return a
	}
	return b
}

func build(node, l, r int) {
	if l == r {
		if ptr[l] < end[l] {
			seg[node] = items[ptr[l]].s
		} else {
			seg[node] = INF
		}
		return
	}
	mid := (l + r) >> 1
	build(node<<1, l, mid)
	build(node<<1|1, mid+1, r)
	seg[node] = min64(seg[node<<1], seg[node<<1|1])
}

func pop(node, l, r, qr int, lim int64) {
	if l > qr || seg[node] > lim {
		return
	}
	if l == r {
		g := l
		for ptr[g] < end[g] && items[ptr[g]].s <= lim {
			it := items[ptr[g]]
			queue = append(queue, Cap{p: it.p, rr: it.rr})
			ans++
			ptr[g]++
		}
		if ptr[g] < end[g] {
			seg[node] = items[ptr[g]].s
		} else {
			seg[node] = INF
		}
		return
	}
	mid := (l + r) >> 1
	pop(node<<1, l, mid, qr, lim)
	if qr > mid {
		pop(node<<1|1, mid+1, r, qr, lim)
	}
	seg[node] = min64(seg[node<<1], seg[node<<1|1])
}

func upperBound(a []int64, x int64) int {
	l, r := 0, len(a)
	for l < r {
		m := (l + r) >> 1
		if a[m] <= x {
			l = m + 1
		} else {
			r = m
		}
	}
	return l
}

func main() {
	data, _ := io.ReadAll(os.Stdin)
	idx := 0

	x := nextInt64(data, &idx)
	y := nextInt64(data, &idx)
	p0 := nextInt64(data, &idx)
	r0 := nextInt64(data, &idx)
	n := int(nextInt64(data, &idx))

	items = make([]Item, n)
	r0sq := r0 * r0

	for i := 0; i < n; i++ {
		xi := nextInt64(data, &idx)
		yi := nextInt64(data, &idx)
		mi := nextInt64(data, &idx)
		pi := nextInt64(data, &idx)
		ri := nextInt64(data, &idx)
		dx := xi - x
		dy := yi - y
		s := dx*dx + dy*dy
		items[i] = Item{
			m:  mi,
			s:  s,
			p:  pi,
			rr: ri * ri,
		}
	}

	sort.Slice(items, func(i, j int) bool {
		if items[i].m != items[j].m {
			return items[i].m < items[j].m
		}
		return items[i].s < items[j].s
	})

	for i := 0; i < n; {
		j := i + 1
		for j < n && items[j].m == items[i].m {
			j++
		}
		masses = append(masses, items[i].m)
		start = append(start, i)
		end = append(end, j)
		i = j
	}

	ptr = make([]int, len(start))
	copy(ptr, start)
	seg = make([]int64, 4*len(start))
	build(1, 0, len(start)-1)

	queue = make([]Cap, 1, n+1)
	queue[0] = Cap{p: p0, rr: r0sq}

	for head := 0; head < len(queue); head++ {
		cur := queue[head]
		pos := upperBound(masses, cur.p) - 1
		if pos >= 0 {
			pop(1, 0, len(masses)-1, pos, cur.rr)
		}
	}

	w := bufio.NewWriterSize(os.Stdout, 1<<20)
	fmt.Fprint(w, ans)
	w.Flush()
}