#include <bits/stdc++.h>

using i64 = long long;

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);

    int n, m, k;
    std::cin >> n >> m >> k;

    std::vector<std::vector<int>> adj(n);
    for (int i = 0; i < m; i ++ ) {
        int u, v;
        std::cin >> u >> v;
        u --, v -- ;
        adj[u].push_back(v);
        adj[v].push_back(u);
    }

    int s1, t1, s2, t2;
    std::cin >> s1 >> t1 >> s2 >> t2;
    s1 --, t1 --, s2 --, t2 -- ;

    std::vector dis(n, std::vector<int>(n, -1));
    for (int i = 0; i < n; i ++ ) {
        std::queue<int> q;
        q.push(i);
        dis[i][i] = 0;
        while (!q.empty()) {
            int x = q.front();
            q.pop();
            for (auto y : adj[x]) {
                if (dis[i][y] == -1) {
                    dis[i][y] = dis[i][x] + 1;
                    q.push(y);
                }
            }
        }
    }

    double ans;

    int d0 = dis[s1][t1], d1 = dis[s2][t2];
    if (d0 + d1 == 0) {
        ans = 0;
    } else {
        int t = k / (d0 + d1);
        int rmain = k % (d0 + d1);
        ans = 1. / (t + 1) * (d0 + d1 - rmain) + 1. / (t + 2) * rmain;
    }

    for (int s = 0; s < n; s ++ ) {
        for (int t = s + 1; t < n; t ++ ) {
            if (dis[s][t] == -1 || dis[s1][s] == -1 || dis[t][t1] == -1 || dis[s2][s] == -1 || dis[t][t2] == -1) {
                continue;
            }
            int both = dis[s][t];
            int dis1 = dis[s1][s] + dis[t][t1];
            int dis2 = dis[s2][s] + dis[t][t2];

            auto f = [&](int x) {
                if (x * both > k) {
                    return 1E9;
                }
                int nk = k;
                double res = 2. / (x + 1) * both;
                nk -= x * both;
                if (dis1 + dis2 > 0) {
                    int t = nk / (dis1 + dis2);
                    res += 1. / (t + 1) * (dis1 + dis2);
                    nk -= t * (dis1 + dis2);
                    if (nk > 0) {
                        if (std::min(both - 1, nk) * 2. / (x + 1) / (x + 2) > nk * 1. / (t + 1) / (t + 2)) {
                            res -= std::min(both - 1, nk) * 2. / (x + 1) / (x + 2);
                        } else {
                            res -= nk * 1. / (t + 1) / (t + 2);
                        }
                    }
                } else {
                    res -= std::min(both - 1, nk) * 2. / (x + 1) / (x + 2);
                }
                return res;
            };

            for (int i = 0; i <= k; i ++ ) {
                ans = std::min(ans, f(i));
            }
        }
    }
    std::cout << std::fixed << std::setprecision(9) << ans << "\n";

    return 0;
}