package main

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

const MOD = 1000000007

var fact, invFact [2005]int64

func power(base, exp int64) int64 {
	res := int64(1)
	base %= MOD
	for exp > 0 {
		if exp%2 == 1 {
			res = (res * base) % MOD
		}
		base = (base * base) % MOD
		exp /= 2
	}
	return res
}

func precompute() {
	fact[0] = 1
	invFact[0] = 1
	for i := 1; i <= 2000; i++ {
		fact[i] = (fact[i-1] * int64(i)) % MOD
	}
	invFact[2000] = power(fact[2000], MOD-2)
	for i := 1999; i >= 1; i-- {
		invFact[i] = (invFact[i+1] * int64(i+1)) % MOD
	}
}

func nCr(n, r int) int64 {
	if r < 0 || r > n {
		return 0
	}
	num := fact[n]
	den := (invFact[r] * invFact[n-r]) % MOD
	return (num * den) % MOD
}

func min(a, b int) int {
	if a < b {
		return a
	}
	return b
}

func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

func main() {
	precompute()
	reader := bufio.NewReader(os.Stdin)
	var N, M, R int
	if _, err := fmt.Fscanf(reader, "%d %d %d\n", &N, &M, &R); err != nil {
		return
	}

	X := make([]int, N)
	Y := make([]int, N)
	B := make([]int64, N)

	var P [1005][1005]int

	for i := 0; i < N; i++ {
		fmt.Fscanf(reader, "%d %d %d\n", &X[i], &Y[i], &B[i])
		B[i] %= MOD
		P[X[i]][Y[i]]++
	}

	for i := 1; i <= 1000; i++ {
		for j := 1; j <= 1000; j++ {
			P[i][j] = P[i][j] + P[i-1][j] + P[i][j-1] - P[i-1][j-1]
		}
	}

	query := func(x1, y1, x2, y2 int) int {
		x1 = max(1, x1)
		y1 = max(1, y1)
		x2 = min(1000, x2)
		y2 = min(1000, y2)
		if x1 > x2 || y1 > y2 {
			return 0
		}
		return P[x2][y2] - P[x1-1][y2] - P[x2][y1-1] + P[x1-1][y1-1]
	}

	Nj := make([]int, N)
	var S int64 = 0
	var S1 int64 = 0

	for i := 0; i < N; i++ {
		Nj[i] = query(X[i]-R, Y[i]-R, X[i]+R, Y[i]+R)
		S = (S + B[i]) % MOD
		S1 = (S1 + B[i]*nCr(N-Nj[i], M)) % MOD
	}

	ans := (nCr(N, M) * ((S * S) % MOD)) % MOD
	sub := (2 * S) % MOD
	sub = (sub * S1) % MOD
	ans = (ans - sub + MOD) % MOD

	var lastTerm int64 = 0
	for j := 0; j < N; j++ {
		for k := 0; k < N; k++ {
			xmin := max(X[j], X[k]) - R
			xmax := min(X[j], X[k]) + R
			ymin := max(Y[j], Y[k]) - R
			ymax := min(Y[j], Y[k]) + R

			Njk := query(xmin, ymin, xmax, ymax)
			N_union := Nj[j] + Nj[k] - Njk

			term := (B[j] * B[k]) % MOD
			term = (term * nCr(N-N_union, M)) % MOD
			lastTerm = (lastTerm + term) % MOD
		}
	}

	ans = (ans + lastTerm) % MOD
	fmt.Println(ans)
}