package main

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

type Line struct {
	A, B, C int64
}

type Segment struct {
	A, B, C                    int64
	min2x, max2x, min2y, max2y int64
}

type Range struct {
	start, end int
}

func abs(a int64) int64 {
	if a < 0 {
		return -a
	}
	return a
}

func gcd(a, b int64) int64 {
	for b != 0 {
		a, b = b, a%b
	}
	return a
}

func normalize(A, B, C int64) (int64, int64, int64) {
	g := gcd(abs(A), gcd(abs(B), abs(C)))
	if g != 0 {
		A /= g
		B /= g
		C /= g
	}
	if A < 0 || (A == 0 && B < 0) {
		A = -A
		B = -B
		C = -C
	}
	return A, B, C
}

type Scanner struct {
	buf []byte
	pos int
}

func NewScanner() *Scanner {
	b, _ := io.ReadAll(os.Stdin)
	return &Scanner{buf: b, pos: 0}
}

func (s *Scanner) nextInt() int64 {
	for s.pos < len(s.buf) && s.buf[s.pos] <= ' ' {
		s.pos++
	}
	if s.pos >= len(s.buf) {
		return 0
	}
	sign := int64(1)
	if s.buf[s.pos] == '-' {
		sign = -1
		s.pos++
	}
	v := int64(0)
	for s.pos < len(s.buf) && s.buf[s.pos] > ' ' {
		v = v*10 + int64(s.buf[s.pos]-'0')
		s.pos++
	}
	return v * sign
}

func main() {
	scanner := NewScanner()
	n := int(scanner.nextInt())
	m := int(scanner.nextInt())

	if n == 0 {
		return
	}

	segments := make([]Segment, n)
	for i := 0; i < n; i++ {
		x1 := scanner.nextInt()
		y1 := scanner.nextInt()
		x2 := scanner.nextInt()
		y2 := scanner.nextInt()

		A := y1 - y2
		B := x2 - x1
		C := x1*y2 - x2*y1
		A, B, C = normalize(A, B, C)

		min2x, max2x := x1*2, x2*2
		if min2x > max2x {
			min2x, max2x = max2x, min2x
		}
		min2y, max2y := y1*2, y2*2
		if min2y > max2y {
			min2y, max2y = max2y, min2y
		}

		segments[i] = Segment{A, B, C, min2x, max2x, min2y, max2y}
	}

	sort.Slice(segments, func(i, j int) bool {
		if segments[i].A != segments[j].A {
			return segments[i].A < segments[j].A
		}
		if segments[i].B != segments[j].B {
			return segments[i].B < segments[j].B
		}
		return segments[i].C < segments[j].C
	})

	lineMap := make(map[Line]Range)
	for i := 0; i < n; {
		j := i
		for j < n && segments[j].A == segments[i].A && segments[j].B == segments[i].B && segments[j].C == segments[i].C {
			j++
		}
		lineMap[Line{segments[i].A, segments[i].B, segments[i].C}] = Range{i, j}
		i = j
	}

	type Circle struct {
		x, y, r int64
	}
	circles := make([]Circle, m)
	for i := 0; i < m; i++ {
		circles[i].x = scanner.nextInt()
		circles[i].y = scanner.nextInt()
		circles[i].r = scanner.nextInt()
	}

	ans := int64(0)
	for i := 0; i < m; i++ {
		for j := i + 1; j < m; j++ {
			c1 := circles[i]
			c2 := circles[j]
			if c1.r != c2.r {
				continue
			}
			dx := c2.x - c1.x
			dy := c2.y - c1.y
			if dx*dx+dy*dy <= 4*c1.r*c1.r {
				continue
			}

			A := 2 * dx
			B := 2 * dy
			C := c1.x*c1.x - c2.x*c2.x + c1.y*c1.y - c2.y*c2.y
			A, B, C = normalize(A, B, C)

			rng, ok := lineMap[Line{A, B, C}]
			if !ok {
				continue
			}

			mx := c1.x + c2.x
			my := c1.y + c2.y
			for k := rng.start; k < rng.end; k++ {
				s := segments[k]
				if mx >= s.min2x && mx <= s.max2x && my >= s.min2y && my <= s.max2y {
					ans++
				}
			}
		}
	}

	fmt.Println(ans)
}