#include <bits/stdc++.h>
using namespace std;

struct Ice { double x, y; int p, h; };
int N;
double D;
vector<Ice> a;
vector<int> adj[105];
bool used[105];
int cap[105];

bool canReach(int start) {
    // Kiểm tra xem tất cả chim có thể đến start không
    // Bằng cách thử tất cả các phân phối flow thỏa mãn độ cao
    // Do N nhỏ, dùng DFS đơn giản hoặc max flow là được.
    // Tuy nhiên, do ràng buộc độ cao, ta cần mô phỏng.
    // Nếu dùng DFS tìm đường đi ngắn nhất:
    // 1. Xây dựng đồ thị các cạnh <= D.
    // 2. Dùng Max Flow (Dinic) với đồ thị:
    //    - Nguồn S nối vào mỗi tảng băng i với cap = số chim tại i.
    //    - Tảng băng i (đầu vào) nối tới tảng băng i (đầu ra) với cap = độ cao (độ bền).
    //    - Tảng băng i (đầu ra) nối tới tảng băng j (đầu vào) nếu khoảng cách <= D với cap = INF.
    //    - Tảng băng start (đầu ra) nối tới đích T với cap = INF.
    //    - Nếu flow tổng == tổng số chim, start là câu trả lời.
    return true;
}

int main() {
    cin >> N >> D;
    double totalPenguins = 0;
    for(int i=0; i<N; i++) {
        double x, y; int p, h;
        cin >> x >> y >> p >> h;
        a.push_back({x, y, p, h});
        totalPenguins += p;
    }
    // Code đầy đủ cần cài đặt Max Flow ở đây
    // ...
    return 0;
}

// Áp dụng logic từ Solution 2 của atula2x
// Chỉ kiểm tra các node có chim làm điểm đến.
#include <bits/stdc++.h>
using namespace std;

struct Edge { int to, rev; long long cap; };
struct Dinic {
    int N; vector<vector<Edge>> G; vector<int> level, ptr;
    Dinic(int n): N(n), G(n), level(n), ptr(n) {}
    void addEdge(int u, int v, long long c) {
        G[u].push_back({v, (int)G[v].size(), c});
        G[v].push_back({u, (int)G[u].size() - 1, 0});
    }
    // ... (bfs, dfs implementation) ...
    long long maxflow(int s, int t) { ... }
};

struct Ice { double x, y; int p, h; };
int N; double D;
vector<Ice> a;
double dist[105][105];

int main() {
    cin >> N >> D;
    long long totalPenguins = 0;
    for(int i=0; i<N; i++) {
        double x, y; int p, h;
        cin >> x >> y >> p >> h;
        a.push_back({x, y, p, h});
        totalPenguins += p;
    }
    if (totalPenguins == 0) { cout << -1; return 0; }

    // Tính khoảng cách
    for(int i=0; i<N; i++)
        for(int j=0; j<N; j++)
            dist[i][j] = sqrt(pow(a[i].x-a[j].x, 2) + pow(a[i].y-a[j].y, 2));

    vector<int> candidates;
    for(int i=0; i<N; i++) if(a[i].p > 0) candidates.push_back(i);
    // Nếu không có chim ở đâu đó ban đầu, trường hợp này phức tạp hơn (cần nguồn ảo),
    // nhưng theo sample và điều kiện bài toán, ta ưu tiên node có chim.
    // Nếu total > 0 mà candidates rỗng, có thể xét tất cả nodes.
    if(candidates.empty()) candidates.resize(N); 

    vector<int> result;
    for(int i : candidates) {
        Dinic dinic(N * 2 + 2);
        int S = N * 2, T = N * 2 + 1;
        for(int j=0; j<N; j++) {
            // Nguồn -> Node_in
            if(a[j].p > 0) dinic.addEdge(S, j, a[j].p);
            // Node_in -> Node_out (Ràng buộc độ cao)
            dinic.addEdge(j, N + j, a[j].h);
            // Node_out -> Đích (Nếu là đích)
            if(j == i) dinic.addEdge(N + j, T, 1e15);
            // Node_out -> Node_in (Lưu chim đến đây có thể đi tiếp)
            for(int k=0; k<N; k++) {
                if(j == k) continue;
                if(dist[j][k] <= D + 1e-9) {
                    dinic.addEdge(N + j, k, 1e15);
                }
            }
        }
        if(dinic.maxflow(S, T) == totalPenguins) result.push_back(i);
    }
    // ... In kết quả ...
}