#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, 1E9));
    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] > dis[i][x] + 1) {
                    dis[i][y] = dis[i][x] + 1;
                    q.push(y);
                }
            }
        }
    }

    long 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;
    }

    std::vector<int> d(n, 1E9);
    for (int s = 0; s < n; s ++ ) {
        for (int t = 0; t < n; t ++ ) {
            int both = dis[s][t];
            int dis1 = std::min(dis[s1][s] + dis[t][t1], dis[s1][t] + dis[s][t1]);
            int dis2 = std::min(dis[s2][s] + dis[t][t2], dis[s2][t] + dis[s][t2]);
            // std::cerr << s << " " << t << " " << both << " " << dis1 << " " << dis2 << "\n";
            if (both == 0 || both >= n) {
                continue;
            }
            d[both] = std::min(d[both], dis1 + dis2);
        }
    }

    for (int i = 1; i < n; i ++ ) {
        // std::cerr << i << " " << d[i] << "\n";
        if (d[i] >= n * 2) {
            continue;
        }
        auto f = [&](int x) -> long double {
            if (1LL * x * i > k) {
                return 1E18;
            }
            int nk = k - x * i;
            long double ans = 1E18;
            for (int j = 0; j <= std::min(nk, i - 1); j ++ ) {
                long double res = 2. / (x + 1) * i - 2. / (x + 1) / (x + 2) * j;
                int nnk = nk;
                nnk -= j;
                if (d[i] > 0) {
                    int t = nnk / d[i];
                    res += 1. / (t + 1) * d[i];
                    nnk -= t * d[i];
                    res -= nnk * 1. / (t + 1) / (t + 2);
                }
                ans = std::min(ans, res);
            }
            return ans;
        };
        int lo = 0, hi = k;
        while (lo <= hi) {
            int m = (hi - lo) / 3;
            int l = lo + m, r = hi - m;
            if (f(l) > f(r)) {
                ans = std::min(ans, f(r));
                lo = l + 1;
            } else {
                ans = std::min(ans, f(l));
                hi = r - 1;
            }
        }
        ans = std::min(ans, f(hi));
    }

    std::cout << std::fixed << std::setprecision(9) << ans << "\n";

    return 0;
}