#include <bits/stdc++.h>
using namespace std;

/*
Lời giải chuẩn:

- Nhị phân thời gian T.
- check(T): mô phỏng m = ceil(n/k) chuyến.
Mô phỏng theo thời gian tích lũy:
    - time: thời gian đã trôi qua.
    - pos: vị trí xe (cũng là vị trí nhóm vừa được thả).
    - Nhóm tiếp theo luôn đi bộ từ 0, nên tại thời điểm time họ ở vị trí walk = v1*time.
    - Xe (ở pos) quay lại để gặp họ: cần t_back sao cho:
            pos - v2*t_back = walk + v1*t_back
      =>    t_back = (pos - walk) / (v1 + v2), nếu pos > walk, ngược lại t_back=0.
      Sau đó xe và nhóm gặp tại meet = walk + v1*t_back.
    - Xe chở nhóm từ meet tiến về phía trước đến pos_new trong t_go = (pos_new - meet)/v2.
      Ta chọn pos_new lớn nhất sao cho nếu thả ở đó thì họ kịp đi bộ nốt về đích trong T:
            time + t_back + t_go + (l - pos_new)/v1 <= T
      =>    pos_new <= l - v1*(T - (time + t_back + t_go))
      Giải trực tiếp cho pos_new:
            time2 = time + t_back
            Cần time2 + (pos_new - meet)/v2 + (l - pos_new)/v1 <= T
      Biến đổi:
            (pos_new - meet)/v2 - pos_new/v1 <= T - time2 - l/v1
            pos_new*(1/v2 - 1/v1) <= T - time2 - l/v1 + meet/v2
      Do (1/v2 - 1/v1) < 0, ta suy ra pos_new >= một ngưỡng.
      Trong tối ưu, ta luôn chọn pos_new = l (chở thẳng về) ở chuyến cuối,
      còn các chuyến trước chọn pos_new sao cho vừa đủ còn quay lại.
Thực tế, cách mô phỏng tối thiểu-time (không nhị phân) cũng được, nhưng nhị phân + check an toàn.

Lưu ý: Để ngắn gọn và chắc chắn, dưới đây dùng nhị phân + công thức đóng cho pos_new tối đa hợp lệ:
    From inequality:
        time2 + (pos_new - meet)/v2 + (l - pos_new)/v1 <= T
    Solve for pos_new:
        pos_new <= ( (T - time2) * v1 * v2 - l * v2 + meet * v1 ) / (v1 - v2)
    Vì v1 - v2 < 0 nên cần cẩn thận dấu; ta dùng long double và tính trực tiếp nghiệm,
    rồi clamp trong [meet, l].
*/

static inline bool check(long double T, long long n, long long l, long long v1, long long v2, long long k) {
    long long m = (n + k - 1) / k;
    long double time = 0.0L;
    long double pos = 0.0L; // vị trí xe sau khi thả nhóm hiện tại

    for (long long trip = 1; trip <= m; trip++) {
        // vị trí nhóm kế tiếp (đang đi bộ) tại thời điểm hiện tại
        long double walk = (long double)v1 * time;

        // quay lại để gặp (nếu xe đang ở phía trước)
        long double t_back = 0.0L;
        if (pos > walk) {
            t_back = (pos - walk) / ( (long double)v1 + (long double)v2 );
        }
        time += t_back;
        long double meet = walk + (long double)v1 * t_back; // vị trí gặp nhau

        // chuyến cuối: chở thẳng tới khách sạn
        if (trip == m) {
            time += ((long double)l - meet) / (long double)v2;
            return time <= T + 1e-12;
        }

        // Chọn pos_new lớn nhất sao cho nhóm này nếu bị thả ở pos_new thì kịp về trong T
        // time + (pos_new - meet)/v2 + (l - pos_new)/v1 <= T
        // Giải ra pos_new:
        // pos_new*(1/v2 - 1/v1) <= T - time - l/v1 + meet/v2
        // pos_new >= (T - time - l/v1 + meet/v2) / (1/v2 - 1/v1)
        // Do mẫu âm, để lấy pos_new lớn nhất vẫn thỏa, ta clamp pos_new = l (nhưng không được vì còn cần quay lại).
        // Trong mô phỏng check, ta chỉ cần một pos_new khả thi để tiếp tục; chọn pos_new sao cho đúng biên:
        long double rhs = (long double)T - time - (long double)l / (long double)v1 + meet / (long double)v2;
        long double denom = 1.0L / (long double)v2 - 1.0L / (long double)v1; // âm
        long double pos_new = rhs / denom; // sẽ là một giá trị trong [meet, l] nếu khả thi

        // Clamp để tránh sai số
        pos_new = min((long double)l, max(meet, pos_new));

        // cập nhật thời gian xe chở đến pos_new
        time += (pos_new - meet) / (long double)v2;
        pos = pos_new;

        // Nếu đã vượt quá T thì fail sớm
        if (time > T) return false;
    }
    return false;
}

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

    long long n, l, v1, v2, k;
    cin >> n >> l >> v1 >> v2 >> k;

    long double lo = 0.0L, hi = (long double)l / (long double)v1; // đi bộ toàn bộ là upper bound
    for (int it = 0; it < 80; it++) {
        long double mid = (lo + hi) / 2.0L;
        if (check(mid, n, l, v1, v2, k)) hi = mid;
        else lo = mid;
    }

    cout.setf(std::ios::fixed); cout << setprecision(10) << (double)hi << "\n";
    return 0;
}