#include <map>
#include <set>
#include <array>
#include <cmath>
#include <deque>
#include <bitset>
#include <random>
#include <string>
#include <vector>
#include <cassert>
#include <complex>
#include <iomanip>
#include <iostream>
#include <algorithm>
#include <unordered_map>
#include <unordered_set>

using namespace std;

struct Point{
	int128_t x, y;
	//Point(int128_t x, int128_t y): x(x), y(y) {}
	Point(int128_t x, int128_t y): x(x), y(y) {}
	Point(): x(0), y(0) {}
};

Point operator+(const Point& first, const Point& second) {
	return Point(first.x + second.x, first.y + second.y);
}

Point operator-(const Point& first, const Point& second) {
	return Point(first.x - second.x, first.y - second.y);
}

int128_t cross(const Point& first, const Point& second) {
	return first.x * second.y - first.y * second.x;
}

int128_t dot(const Point& first, const Point& second) {
	return first.x * second.x + first.y * second.y;
}

int128_t sqrlen(const Point& P) {
	return P.x * P.x + P.y * P.y;
}

Point operator*(const Point& A, int128_t c) {
	return Point(A.x * c, A.y * c);
}

bool operator==(const Point& P, const Point& Q) {
	return P.x == Q.x && P.y == Q.y;
}

void print(Point P) {
	cout << int(P.x) << ' ' << int(P.y) << '\n';
}

void print(int128_t x) {
	cout << int(x) << '\n';
}

int128_t r, d;

struct Circle {
	Point c;
	int128_t t1, t2;
	Circle(Point c, int128_t t1, int128_t t2): c(c), t1(t1), t2(t2) {}
};

struct MoveCircle {
	Point a, b;
	int128_t t1, t2;
	MoveCircle(Point a, Point b, int128_t t1, int128_t t2): a(a), b(b), t1(t1), t2(t2) {}
};

bool circles_intersect_good(Circle C1, Circle C2, int128_t d) {
	int128_t t1 = max(C1.t1, C2.t1);
	int128_t t2 = min(C1.t2, C2.t2);
	if (t1 > t2)
		return false;
	return sqrlen(C1.c - C2.c) <= d;
}

struct Line {
	int128_t a;
	int128_t b;
	int128_t c;
	Line(Point A, Point B) {
		a = A.y - B.y;
		b = B.x - A.x;
		c = -a * A.x - b * A.y;
	}
	int128_t at(Point P) {
		return a * P.x + b * P.y + c;
	}
};

int128_t sign(int128_t x) {
	if (x > 0)
		return 1;
	if (x < 0)
		return -1;
	return 0;
}

int128_t abs(int128_t x) {
	return x * sign(x);
}

bool point_segm_intersect_good(Point A, Point B, Point C, int128_t d) {
	assert(abs(A.x) <= 1e7);
	assert(abs(A.y) <= 1e7);
	assert(abs(B.x) <= 1e7);
	assert(abs(B.y) <= 1e7);
	assert(abs(C.x) <= 1e7);
	assert(abs(C.y) <= 1e7);
	
	if (B == C) {
		return sqrlen(A - B) <= d;
	}
	if (dot(A - B, C - B) >= 0 && dot(A - C, B - C) >= 0) {
		Line l(B, C);
		return l.at(A) * l.at(A) <= d * (l.a * l.a + l.b * l.b); // might overflow
	}
	return min(sqrlen(A - C), sqrlen(A - B)) <= d;
}

bool segm_segm_intersect_good(Point A, Point B, Point C, Point D, int128_t d) {
	if (point_segm_intersect_good(A, C, D, d) || point_segm_intersect_good(B, C, D, d) || point_segm_intersect_good(C, A, B, d) || point_segm_intersect_good(D, A, B, d))
		return true;
	if (A == B)
		return false;
	if (C == D)
		return false;
	Line l1(A, B);
	Line l2(C, D);
	if (sign(l1.at(C)) * sign(l1.at(D)) <= 0 && sign(l2.at(A)) * sign(l2.at(B)) <= 0)
		return true;
	return false;
}

bool slider_with_circle(Circle C, MoveCircle k) {
	int128_t t1 = max(C.t1, k.t1 - d);
	int128_t t2 = min(C.t2, k.t2 + d);
	if (t1 > t2)
		return false;
	return point_segm_intersect_good(C.c, k.a, k.b, 4 * r * r);
}

bool circle_moving_circle(Circle C, MoveCircle k) {
	Circle kek1(k.a, k.t1 - d, k.t1);
	Circle kek2(k.b, k.t2, k.t2 + d);
	if (circles_intersect_good(C, kek1, 4 * r * r)) {
		return true;
	}
	if (circles_intersect_good(C, kek2, 4 * r * r)) {
		return true;
	}
	int128_t to_mul = k.t2 - k.t1;
	Point P = C.c * to_mul;
	Point delta = k.b - k.a;
	Point A = k.a * to_mul;
	Point B = k.b * to_mul;
	int128_t t1 = max(C.t1, k.t1);
	int128_t t2 = min(C.t2, k.t2);
	if (t1 > t2)
		return false;
	A = A + delta * (t1 - k.t1);
	B = B - delta * (k.t2 - t2);
	return point_segm_intersect_good(P, A, B, 4 * r * r * to_mul * to_mul);
}

int main() {
	ios::sync_with_stdio(false);
	cin.tie(0);
	cout.tie(0);

	int n, rr, dd;
	cin >> n >> rr >> dd;
	r = rr;
	d = dd;
	vector<Circle> circles;
	vector<MoveCircle> move_circles;
	for (int i = 0; i < n; ++i) {
		int t;
		cin >> t;
		if (t == 1) {
			int x, y, t;
			cin >> x >> y >> t;
			circles.emplace_back(Point(x, y), t - d, t + d);
		} else {
			int x1, y1, x2, y2, u, v;
			cin >> x1 >> y1 >> x2 >> y2 >> u >> v;
			move_circles.emplace_back(Point(x1, y1), Point(x2, y2), u, v);
		}
	}
	int ans = 0;
	// circle with circle
	for (int i = 0; i < circles.size(); ++i) {
		for (int j = 0; j < i; ++j) {
			Circle C1 = circles[i];
			Circle C2 = circles[j];
			if (circles_intersect_good(C1, C2, 4 * r * r))
				++ans;
		}
	}
	// circle with moving
	for (Circle C : circles) {
		for (MoveCircle k : move_circles) {
			ans += circle_moving_circle(C, k);
		}
	}
	// circle with slider
	for (Circle C : circles) {
		for (MoveCircle k : move_circles) {
			ans += slider_with_circle(C, k);
		}
	}
	// slider with slider
	for (int i = 0; i < move_circles.size(); ++i) {
		for (int j = 0; j < i; ++j) {
			auto lol = move_circles[i];
			auto kek = move_circles[j];
			int128_t t1 = max(lol.t1 - d, kek.t1 - d);
			int128_t t2 = min(lol.t2 + d, kek.t2 + d);
			if (t1 <= t2) {
				ans += segm_segm_intersect_good(lol.a, lol.b, kek.a, kek.b, 4 * r * r);
			}
		}
	}
	// slider with moving
	for (auto lol : move_circles) {
		for (auto kek : move_circles) {
			if (slider_with_circle(Circle(kek.a, kek.t1 - d, kek.t1), lol)) {
				++ans;
				continue;
			}
			if (slider_with_circle(Circle(kek.b, kek.t2, kek.t2 + d), lol)) {
				++ans;
				continue;
			}
			int128_t to_mul = kek.t2 - kek.t1;
			Point delta = kek.b - kek.a;
			int128_t t1 = max(lol.t1 - d, kek.t1);
			int128_t t2 = min(lol.t2 + d, kek.t2);
			if (t1 > t2)
				continue;
			Point A = kek.a * to_mul + delta * (t1 - kek.t1);
			Point B = kek.b * to_mul - delta * (kek.t2 - t2);
			if (segm_segm_intersect_good(lol.a * to_mul, lol.b * to_mul, A, B, 4 * r * r * to_mul * to_mul)) {
				++ans;
			}
		}
	}
	// moving with moving
	for (int i = 0; i < move_circles.size(); ++i) {
		for (int j = 0; j < i; ++j) {
			auto lol = move_circles[i];
			Circle lol1(lol.a, lol.t1 - d, lol.t1);
			Circle lol2(lol.b, lol.t2, lol.t2 + d);
			auto kek = move_circles[j];
			Circle kek1(kek.a, kek.t1 - d, kek.t1);
			Circle kek2(kek.b, kek.t2, kek.t2 + d);
			if (circle_moving_circle(lol1, kek) || circle_moving_circle(lol2, kek) ||
				circle_moving_circle(kek1, lol) || circle_moving_circle(kek2, lol)) {
				++ans;
				continue;
			}


			int128_t t1 = max(lol.t1, kek.t1);
			int128_t t2 = min(lol.t2, kek.t2);
			if (t1 > t2)
				continue;
			int128_t lol_t = lol.t2 - lol.t1;
			int128_t kek_t = kek.t2 - kek.t1;
			// up to 1e10
			Point lol_a = lol.a * lol_t * kek_t;
			Point lol_b = lol.b * lol_t * kek_t;
			Point kek_a = kek.a * lol_t * kek_t;
			Point kek_b = kek.b * lol_t * kek_t;
			// up to 1e7
			Point move_lol = (lol.b - lol.a) * kek_t;
			Point move_kek = (kek.b - kek.a) * lol_t;
			Point real_st = (lol_a + move_lol * (t1 - lol.t1)) - (kek_a + move_kek * (t1 - kek.t1));
			Point real_move = move_lol - move_kek;

			// up to 2e14
			int128_t a = sqrlen(real_move);
			// up to 4e17
			int128_t b = 2 * real_move.x * real_st.x + 2 * real_move.y * real_st.y;
			// up to 2e20
			int128_t c = sqrlen(real_st);

			int128_t mxt = t2 - t1;

			int128_t need = 4 * r * r * kek_t * kek_t * lol_t * lol_t;
			if (c <= need || a * mxt * mxt + b * mxt + c <= need) {
				++ans;
				continue;
			}

			// min is in the (-b/(2a))
			if (b >= 0)
				continue;
			if (-b >= 2 * a * mxt)
				continue;
			// b^2/(4a) >= c - need
			if (b * b / (4 * a) >= c - need) {
				++ans;
			}
		}
	}
	cout << ans << '\n';
	return 0;
}

answer.code:21:9: error: ‘int128_t’ does not name a type; did you mean ‘int8_t’?
   21 |         int128_t x, y;
      |         ^~~~~~~~
      |         int8_t
answer.code:23:23: error: expected ‘)’ before ‘x’
   23 |         Point(int128_t x, int128_t y): x(x), y(y) {}
      |              ~        ^~
      |                       )
answer.code: In constructor ‘Point::Point()’:
answer.code:24:18: error: class ‘Point’ does not have any field named ‘x’
   24 |         Point(): x(0), y(0) {}
      |                  ^
answer.code:24:24: error: class ‘Point’ does not have any field named ‘y’
   24 |         Point(): x(0), y(0) {}
      |                        ^
answer.code: In function ‘Point operator+(const Point&, const Point&)’:
answer.code:28:28: error: ‘const struct Point’ has no member named ‘x’
   28 |         return Point(first.x + second.x, first.y + second.y);
      |                            ^
answer.code:28:39: error: ‘const struct Point’ has no member named ‘x’
   28 |         return Point(first.x + second.x, first.y + second.y);
      |                                       ^
answer.code:28:48: error: ‘const struct Point’ has no member named ‘y’
   28 |         return Point(first.x + second.x, first.y + second.y);
      |                                                ^
answer.code:28:59: error: ‘const struct Point’ has no member named ‘y’
   28 |         return Point(first.x + second.x, first.y + second.y);
      |                                                           ^
answer.code: In function ‘Point operator-(const Point&, const Point&)’:
answer.code:32:28: error: ‘const struct Point’ has no member named ‘x’
   32 |         return Point(first.x - second.x, first.y - second.y);
      |                            ^
answer.code:32:39: error: ‘const struct Point’ has no member named ‘x’
   32 |         return Point(first.x - second.x, first.y - second.y);
      |                                       ^
answer.code:32:48: error: ‘const struct Point’ has no member named ‘y’
   32 |         return Point(first.x - second.x, first.y - second.y);
      |                                                ^
answer.code:32:59: error: ‘const struct Point’ has no member named ‘y’
   32 |         return Point(first.x - second.x, first.y - second.y);
      |                                                           ^
answer.code: At global scope:
answer.code:35:1: error: ‘int128_t’ does not name a type; did you mean ‘int8_t’?
   35 | int128_t cross(const Point& first, const Point& second) {
      | ^~~~~~~~
      | int8_t
answer.code:39:1: error: ‘int128_t’ does not name a type; did you mean ‘int8_t’?
   39 | int128_t dot(const Point& first, const Point& second) {
      | ^~~~~~~~
      | int8_t
answer.code:43:1: error: ‘int128_t’ does not name a type; did you mean ‘int8_t’?
   43 | int128_t sqrlen(const Point& P) {
      | ^~~~~~~~
      | int8_t
answer.code:47:33: error: ‘int128_t’ has not been declared
   47 | Point operator*(const Point& A, int128_t c) {
      |                                 ^~~~~~~~
answer.code: In function ‘Point operator*(const Point&, int)’:
answer.code:48:24: error: ‘const struct Point’ has no member named ‘x’
   48 |         return Point(A.x * c, A.y * c);
      |                        ^
answer.code:48:33: error: ‘const struct Point’ has no member named ‘y’
   48 |         return Point(A.x * c, A.y * c);
      |                                 ^
answer.code: In function ‘bool operator==(const Point&, const Point&)’:
answer.code:52:18: error: ‘const struct Point’ has no member named ‘x’
   52 |         return P.x == Q.x && P.y == Q.y;
      |                  ^
answer.code:52:25: error: ‘const struct Point’ has no member named ‘x’
   52 |         return P.x == Q.x && P.y == Q.y;
      |                         ^
answer.code:52:32: error: ‘const struct Point’ has no member named ‘y’
   52 |         return P.x == Q.x && P.y == Q.y;
      |                                ^
answer.code:52:39: error: ‘const struct Point’ has no member named ‘y’
   52 |         return P.x == Q.x && P.y == Q.y;
      |                                       ^
answer.code: In function ‘void print(Point)’:
answer.code:56:23: error: ‘struct Point’ has no member named ‘x’
   56 |         cout << int(P.x) << ' ' << int(P.y) << '\n';
      |                       ^
answer.code:56:42: error: ‘struct Point’ has no member named ‘y’
   56 |         cout << int(P.x) << ' ' << int(P.y) << '\n';
      |                                          ^
answer.code: At global scope:
answer.code:59:6: error: variable or field ‘print’ declared void
   59 | void print(int128_t x) {
      |      ^~~~~
answer.code:59:12: error: ‘int128_t’ was not declared in this scope; did you mean ‘int8_t’?
   59 | void print(int128_t x) {
      |            ^~~~~~~~
      |            int8_t
answer.code:63:1: error: ‘int128_t’ does not name a type; did you mean ‘int8_t’?
   63 | int128_t r, d;
      | ^~~~~~~~
      | int8_t
answer.code:67:9...