// @EXPECTED_RESULTS@: TIME_LIMIT_EXCEEDED, WRONG_ANSWER
import java.util.*

fun main() {
    val (n, m, t) = readln().split(" ").map { it.toInt() }
    val epsilon = t + 1e-10
    val epsilonRange = (t - 1e-10..epsilon)
    val graph = System.`in`.bufferedReader().lineSequence().take(m)
        .flatMap { line ->
            val (a, b, l, v) = line.split(" ").map { it.toInt() }
            // add reverse connections
            listOf((a to b) to (l to v), (b to a) to (l to v))
        }.toMap()
    val routes = mutableListOf<List<Pair<Int, Int>>>()
    // state = (location, time, visited)
    val queue = LinkedList<Triple<Int, List<Pair<Int, Int>>, BooleanArray>>()
    queue.add(Triple(1, listOf(), BooleanArray(n + 1) { it == 1 }))
    while (queue.isNotEmpty()) {
        val (location, route, visited) = queue.poll()
        if (location == n) {
            routes.add(route)
        }
        graph.keys.filter { it.first == location }
            .filter { (_, b) -> !visited[b] }
            .map { l -> Triple(l.second, route + listOf(graph[l]!!), visited.copyOf().also { it[l.second] = true }) }
            .toCollection(queue)
    }
    fun cost(route: List<Pair<Int, Int>>, speeding: Double) =
        route.sumOf { (l, v) -> l / (v + speeding) }
    if (routes.any { cost(it, 0.0) <= epsilon }) return println("0")

    routes.minOf { optimal ->
        var low = 0.0
        var high = 1e11
        // binary Search
        do {
            val mid = (low + high) / 2
            val cost = cost(optimal, mid)
            if (cost in epsilonRange) return@minOf mid
            if (cost > epsilon) {
                low = mid + 1e-18
            } else {
                high = mid - 1e-18
            }
        } while (high - low > 1e-6 && 1 - low / high > 1e-6)
        low
    }.also { println(it) }
}