#pragma once
#pragma GCC optimize("Ofast, unroll-loops")
#include <bits/stdc++.h>
using namespace std;
typedef long double ld;
const int N = 100013;
const ld inf = 1e18;
int n, tt;
struct pt {
    int x, y;
    pt operator-(const pt &b)const {
        return{x - b.x, y - b.y};
    } bool operator<(const pt &b)const {
        return y < b.y;
    }
} p[N];
struct ln {
    pt x, y;
} l[N];
ld dp[N];
int sgn(int x) {
    return!x ? 0 : x > 0 ? 1 : -1;
}
int cr(pt x, pt y) {
    return x.x * y.y - x.y * y.x;
}
int f(pt a, pt b, pt c) {
    return cr(c - a, c - b);
}
bool isc(pt x, pt y, ln L) {
    return sgn(f(x, y, L.x)) * sgn(f(x, y, L.y)) < 0 && sgn(f(L.x, L.y, x)) * sgn(f(L.x, L.y, y)) < 0;
}
bool chk(pt x, pt y) {
    for (int i = 0; i < n; i++)
        if (isc(x, y, l[i]))
            return false;

    return true;
}
ld slp(pt x, pt y) {
    return fabsl((ld)(y.x - x.x) / (y.y - x.y));
}
int main() {
    cout << fixed << setprecision(15);
    int m, v;
    cin >> n >> m >> v;

    for (int i = 0, a, b, c, d; i < n; i++)
        cin >> a >> b >> c >> d, l[i] = {{a, b}, {c, d}}, p[tt++] = {a, b}, p[tt++] = {c, d};
    sort(p, p + tt);
    fill(dp, dp + tt, inf);
    ld ans = inf;

    if (chk({0, -10001}, {0, 10001}))
        ans = 0;

    for (int i = 0; i < tt; i++)
        if (abs(p[i].x) < m) {
            if (chk({p[i].x, -10001}, p[i]))
                dp[i] = 0;

            for (int j = 0; j < i; j++) {
                if (p[i].y == p[j].y)
                    break;

                if (chk(p[i], p[j]))
                    dp[i] = min(dp[i], max(dp[j], slp(p[i], p[j])));
            }

            if (chk({p[i].x, 10001}, p[i]))
                ans = min(ans, dp[i]);
        }

    if (ans > 1e17)
        cout << -1 << '\n';
    else
        cout << ans *v << '\n';
}