#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
typedef long double LD;
const int N = 1005;
const LD eps = 1e-10;

inline int sgn(LD x) {
    return x > eps? 1 : x < -eps? -1 : 0;
}

struct Point {
    LD x, y;
    Point(LD _x = 0, LD _y = 0): x(_x), y(_y) {}
    Point operator + (const Point &rhs) const {
        return Point(x + rhs.x, y + rhs.y);
    }
    Point operator - (const Point &rhs) const {
        return Point(x - rhs.x, y - rhs.y);
    }
    Point operator * (const LD &rhs) const {
        return Point(x * rhs, y * rhs);
    }
    Point operator / (const LD &rhs) const {
        return Point(x / rhs, y / rhs);
    }
    LD operator * (const Point &rhs) const {
        return x * rhs.x + y * rhs.y;
    }
    LD operator ^ (const Point &rhs) const {
        return x * rhs.y - y * rhs.x;
    }
    LD len2() {
        return x * x + y * y;
    }
    LD len() {
        return sqrtl(len2());
    }
    Point unit() {
        return (*this) / len();
    }
} p[N], s[N];

Point Proj(Point p, Point u, Point v) {
    Point dir = (v - u).unit();
    return u + dir * (dir * (p - u));
}

LD Time(Point d, Point v) {
    LD ret = d.len() / v.len();
    return (sgn(d * v) >= 0? ret : -ret);
}

int n, vis[N];
LD D, D2, cros1[N][N], cros2[N][N], dis[N];
priority_queue< pair<LD, int> > pq;

void solve() {
    scanf("%d %Lf", &n, &D);
    D2 = D * D;
    for (int i = 0; i <= n; ++i) {
        scanf("%Lf %Lf", &p[i].x, &p[i].y);
        scanf("%Lf %Lf", &s[i].x, &s[i].y);
        dis[i] = 1e18;
    }
    for (int i = 0; i <= n; ++i) {
        for (int j = i + 1; j <= n; ++j) {
            Point vel = s[i] - s[j];
            LD tim1 = 1e18, tim2 = -1e18;
            if (sgn(vel.x) == 0 && sgn(vel.y) == 0) {
                if ((p[i] - p[j]).len2() <= D2) {
                    tim1 = 0;
                    tim2 = 1e18;
                }
            } else {
                Point m = Proj(p[j], p[i], p[i] + vel);
                LD h2 = (p[j] - m).len2();
                if (sgn(D2 - h2) >= 0) {
                    Point m1 = m - vel.unit() * sqrtl(D2 - h2);
                    Point m2 = m + vel.unit() * sqrtl(D2 - h2);
                    tim1 = Time(m1 - p[i], vel);
                    tim2 = Time(m2 - p[i], vel);
                }
            }
            //printf("%d %d %.6Lf %.6Lf\n", i, j, tim1, tim2);
            cros1[i][j] = cros1[j][i] = tim1;
            cros2[i][j] = cros2[j][i] = tim2;
        }
    }
    dis[0] = 0;
    pq.push(make_pair(0, 0));
    while (!pq.empty()) {
        int u = pq.top().second;
        pq.pop();
        if (vis[u]) continue;
        vis[u] = 1;
        for (int v = 1; v <= n; ++v) {
            if (vis[v]) continue;
            if (dis[u] > cros2[u][v]) continue;
            LD cur = max(dis[u], cros1[u][v]);
            assert(((p[u] + s[u] * cur) - (p[v] + s[v] * cur)).len2() <= D2 + eps);
            if (dis[v] > cur) {
                dis[v] = cur;
                pq.push(make_pair(-dis[v], v));
            }
        }
    }
    for (int i = 1; i <= n; ++i) {
        if (dis[i] < 1e17) {
            printf("%.10Lf\n", dis[i]);
        } else {
            puts("-1");
        }
    }
}

int main() {
    solve();
    return 0;
}