#include <bits/stdc++.h>

using i64 = long long;

// struct Frac {
//     i64 x;
//     i64 y;
    
//     Frac(i64 x_ = 0, i64 y_ = 1) : x(x_), y(y_) {
//         if (y < 0) {
//             x = -x;
//             y = -y;
//         }
//     }
// };

// Frac operator*(const Frac &a, const Frac &b) {
//     return Frac(a.x * b.x, a.y * b.y);
// }

// Frac operator/(const Frac &a, const Frac &b) {
//     return Frac(a.x * b.y, a.y * b.x);
// }

// Frac operator+(const Frac &a, const Frac &b) {
//     return Frac(a.x * b.y + a.y * b.x, a.y * b.y);
// }

// Frac operator-(const Frac &a, const Frac &b) {
//     return Frac(a.x * b.y - a.y * b.x, a.y * b.y);
// }

using real = long double;

struct Point {
    real x;
    real y;
    
    Point(const real &x = 0, const real &y = 0) : x(x), y(y) {}
};

std::ostream &operator<<(std::ostream &o, const Point &p) {
    return o << "(" << p.x << ", " << p.y << ")";
}

Point operator+(const Point &a, const Point &b) {
    return Point(a.x + b.x, a.y + b.y);
}

Point operator-(const Point &a, const Point &b) {
    return Point(a.x - b.x, a.y - b.y);
}

Point operator*(const Point &a, const real &b) {
    return Point(a.x * b, a.y * b);
}

Point operator/(const Point &a, const real &b) {
    return Point(a.x / b, a.y / b);
}

real dot(const Point &a, const Point &b) {
    return a.x * b.x + a.y * b.y;
}

real cross(const Point &a, const Point &b) {
    return a.x * b.y - a.y * b.x;
}

real distpp(const Point &a, const Point &b) {
    return dot(a - b, a - b);
}

real distpl(const Point &p, const Point &a, const Point &b) {
    if (dot(a - b, p - b) <= 0) {
        return distpp(p, b);
    } else if (dot(b - a, p - a) <= 0) {
        return distpp(p, a);
    } else {
        real cr = cross(a - p, b - p);
        return cr * cr / dot(a - b, a - b);
    }
}

real distll(const Point &a, const Point &b, const Point &c, const Point &d) {
    if (cross(c - a, b - a) * cross(b - a, d - a) > 0 && cross(a - c, d - c) * cross(d - c, b - c) > 0) {
        return 0;
    }
    return std::min({distpl(a, c, d), distpl(b, c, d), distpl(c, a, b), distpl(d, a, b)});
}

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    
    int N, R, D;
    std::cin >> N >> R >> D;
    
    std::vector<std::tuple<Point, Point, int, int>> point, line;
    for (int i = 0; i < N; i++) {
        int o;
        std::cin >> o;
        
        if (o == 1) {
            int x, y, t;
            std::cin >> x >> y >> t;
            point.emplace_back(Point(x, y), Point(x, y), t, t);
        } else if (o == 2) {
            int x1, y1, x2, y2, u, v;
            std::cin >> x1 >> y1 >> x2 >> y2 >> u >> v;
            point.emplace_back(Point(x1, y1), Point(x2, y2), u, v);
            line.emplace_back(Point(x1, y1), Point(x2, y2), u, v);
        }
    }
    
    auto intersectpp1 = [&](const auto &p1, const auto &p2) {
        auto [a, b, l1, r1] = p1;
        auto [c, d, l2, r2] = p2;
        int l = std::max(l1, l2);
        int r = std::min(r1, r2);
        if (l > r) {
            return false;
        }
        Point v1 = l1 == r1 ? Point() : (b - a) / (r1 - l1);
        Point v2 = l2 == r2 ? Point() : (d - c) / (r2 - l2);
        Point u = a + v1 * (l - l1) - (c + v2 * (l - l2));
        Point v = a + v1 * (r - l1) - (c + v2 * (r - l2));
        
        return distpl(Point(), u, v) <= 4 * R * R;
    };
    
    auto intersectpp = [&](const auto &p1, const auto &p2) {
        auto [a, b, l1, r1] = p1;
        auto [c, d, l2, r2] = p2;
        for (auto x : {std::make_tuple(a, a, l1 - D, l1), {a, b, l1, r1}, {b, b, r1, r1 + D}}) {
            for (auto y : {std::make_tuple(c, c, l2 - D, l2), {c, d, l2, r2}, {d, d, r2, r2 + D}}) {
                if (intersectpp1(x, y)) {
                    return true;
                }
            }
        }
        return false;
    };
    
    auto intersectpl1 = [&](const auto &p1, const auto &p2) {
        auto [a, b, l1, r1] = p1;
        auto [c, d, l2, r2] = p2;
        int l = std::max(l1, l2);
        int r = std::min(r1, r2);
        if (l > r) {
            return false;
        }
        Point v1 = l1 == r1 ? Point() : (b - a) / (r1 - l1);
        Point u = a + v1 * (l - l1);
        Point v = a + v1 * (r - l1);
        return distll(u, v, c, d) <= 4 * R * R;
    };
    
    auto intersectpl = [&](const auto &p1, const auto &p2) {
        auto [a, b, l1, r1] = p1;
        auto [c, d, l2, r2] = p2;
        for (auto x : {std::make_tuple(a, a, l1 - D, l1), {a, b, l1, r1}, {b, b, r1, r1 + D}}) {
            if (intersectpl1(x, std::make_tuple(c, d, l2 - D, r2 + D))) {
                return true;
            }
        }
        return false;
    };
    
    auto intersectll = [&](const auto &p1, const auto &p2) {
        auto [a, b, l1, r1] = p1;
        auto [c, d, l2, r2] = p2;
        l1 -= D, r1 += D;
        l2 -= D, r2 += D;
        int l = std::max(l1, l2);
        int r = std::min(r1, r2);
        if (l > r) {
            return false;
        }
        return distll(a, b, c, d) <= 4 * R * R;
    };
    
    int ans = 0;
    
    for (int i = 0; i < point.size(); i++) {
        for (int j = i + 1; j < point.size(); j++) {
            ans += intersectpp(point[i], point[j]);
        }
    }
    
    for (auto a : point) {
        for (auto b : line) {
            ans += intersectpl(a, b);
        }
    }
    
    for (int i = 0; i < line.size(); i++) {
        for (int j = i + 1; j < line.size(); j++) {
            ans += intersectll(line[i], line[j]);
        }
    }
    
    std::cout << ans << "\n";
    
    return 0;
}