#include <bits/stdc++.h>

using namespace std;

const double eps = 1e-6;

int n, k;
double l, v1, v2;

int main() {
#ifndef ONLINE_JUDGE
  freopen("in", "r", stdin);
  freopen("out", "w", stdout);
#endif
  ios_base::sync_with_stdio(0);
  cin >> n >> l >> v1 >> v2 >> k;
  int gr = (n + k - 1) / k;
  double lo = 0, hi = 1e9;
  while (fabs(lo - hi) > eps) {
    double mid = (lo + hi) / 2;
    bool f = 0;
    double curloc = 0;
    double curtime = 0;
    for (int i = 0; i < gr; i++) {
      curtime += (curloc - curtime * v1) / (v1 + v2);
      curloc = curtime * v1 + mid * v2;
      curtime += mid;
      if (curloc >= l) {
        f = 1;
        break;
      }
    }
    if (f) {
      hi = mid;
    }
    else {
      lo = mid;
    }
  }
  cout << fixed << setprecision(6) << hi + (l - hi * v2) / v1 << "\n";
  return 0;
}


#define _CRT_SECURE_NO_DEPRECATE
#pragma comment(linker, "/STACK:102400000,102400000")
#include<iostream>
#include<cstdio>
#include<fstream>
#include<iomanip>
#include<algorithm>
#include<cmath>
#include<deque>
#include<vector>
#include<assert.h>
#include<bitset>
#include<queue>
#include<string>
#include<cstring>
#include<map>
#include<stack>
#include<set>
#include<functional>
#define pb push_back
#define pii pair<int, int>
#define mod 1000000007
#define mp make_pair
#define pi acos(-1)
#define eps 0.0000001
#define mst(a,i) memset(a,i,sizeof(a))
#define fore(i,fa,fb) for(i=fa;i<=fb;++i)
#define bfore(i,fa,fb) for(i=fb;i>=fa;--i)
#define all(n) (n.begin(),n.end())
#define lson(x) ((x<<1))
#define rson(x) ((x<<1)|1)
#define F first
#define S second
#define inf 0x3f3f3f3f
typedef long long ll;
using namespace std;
double v1, v2, l;
int k, n;
double tempk;
double sumd;
int num1 = 1;
int num2;
int check(double pos)
{
	double nowpos = pos;
	double apos = 0;
	for (int i = 2; i <= num2; ++i)
	{
		double t1 = (nowpos-apos) / v2;
		apos += t1*v1;
		double t2 = (nowpos - apos) / (v2 + v1);
		apos += t2*v1;
		double temp = nowpos;
		nowpos = (v1*v2) / (v2 - v1)*(t2 + temp / v1 - apos / v2);
	}
	if (nowpos >= l)return 1;
	else return 0;
}
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(0);
	int i, j, m;
	cin >> n >> l >> v1 >> v2 >> k;
	sumd = l*n;
	tempk = (v2 + v1) / (v2 * 2);
	if (n%k == 0)num2 = n / k;
	else num2 = n / k + 1;
	double tl = 0, tr = l;
	while (tr - tl >= eps)
	{
		double mid = (tr + tl) / 2;
		if (check(mid))tr = mid;
		else tl = mid;
	}
	cout << setprecision(15) << tl / v2 + (l - tl) / v1;
	return 0;
}


#define _CRT_SECURE_NO_DEPRECATE
#pragma comment(linker, "/STACK:102400000,102400000")
#include<iostream>
#include<cstdio>
#include<fstream>
#include<iomanip>
#include<algorithm>
#include<cmath>
#include<deque>
#include<vector>
#include<assert.h>
#include<bitset>
#include<queue>
#include<string>
#include<cstring>
#include<map>
#include<stack>
#include<set>
#include<functional>
#define pb push_back
#define pii pair<int, int>
#define mod 1000000007
#define mp make_pair
#define pi acos(-1)
#define eps 0.000001
#define mst(a,i) memset(a,i,sizeof(a))
#define fore(i,fa,fb) for(i=fa;i<=fb;++i)
#define bfore(i,fa,fb) for(i=fb;i>=fa;--i)
#define all(n) (n.begin(),n.end())
#define lson(x) ((x<<1))
#define rson(x) ((x<<1)|1)
#define F first
#define S second
#define inf 0x3f3f3f3f
typedef long long ll;
using namespace std;
double v1, v2, l;
int k, n;
double tempk;
double sumd;
int num1 = 1;
int num2;
int check(double pos)
{
	double nowpos = pos;
	double apos = 0;
	for (int i = 2; i <= num2; ++i)
	{
		double t1 = (nowpos-apos) / v2;
		apos += t1*v1;
		double t2 = (nowpos - apos) / (v2 + v1);
		apos += t2*v1;
		double temp = nowpos;
		nowpos = (v1*v2) / (v2 - v1)*(t2 + temp / v1 - apos / v2);
	}
	if (nowpos >= l)return 1;
	else return 0;
}
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(0);
	int i, j, m;
	cin >> n >> l >> v1 >> v2 >> k;
	sumd = l*n;
	tempk = (v2 + v1) / (v2 * 2);
	if (n%k == 0)num2 = n / k;
	else num2 = n / k + 1;
	double tl = 0, tr = l;
	while (tr - tl > eps)
	{
		double mid = (tr + tl) / 2;
		if (check(mid))tr = mid;
		else tl = mid;
	}
	cout << setprecision(15) << tl / v2 + (l - tl) / v1;
	return 0;
}


#define _CRT_SECURE_NO_DEPRECATE
#pragma comment(linker, "/STACK:102400000,102400000")
#include<iostream>
#include<cstdio>
#include<fstream>
#include<iomanip>
#include<algorithm>
#include<cmath>
#include<deque>
#include<vector>
#include<assert.h>
#include<bitset>
#include<queue>
#include<string>
#include<cstring>
#include<map>
#include<stack>
#include<set>
#include<functional>
#define pb push_back
#define pii pair<int, int>
#define mod 1000000007
#define mp make_pair
#define pi acos(-1)
#define eps 0.00000001
#define mst(a,i) memset(a,i,sizeof(a))
#define fore(i,fa,fb) for(i=fa;i<=fb;++i)
#define bfore(i,fa,fb) for(i=fb;i>=fa;--i)
#define all(n) (n.begin(),n.end())
#define lson(x) ((x<<1))
#define rson(x) ((x<<1)|1)
#define F first
#define S second
#define inf 0x3f3f3f3f
typedef long long ll;
using namespace std;
double v1, v2, l;
int k, n;
double tempk;
double sumd;
int num1 = 1;
int num2;
int check(double pos)
{
	double nowpos = pos;
	double apos = 0;
	for (int i = 2; i <= num2; ++i)
	{
		double t1 = (nowpos-apos) / v2;
		apos += t1*v1;
		double t2 = (nowpos - apos) / (v2 + v1);
		apos += t2*v1;
		double temp = nowpos;
		nowpos = (v1*v2) / (v2 - v1)*(t2 + temp / v1 - apos / v2);
	}
	if (nowpos >= l)return 1;
	else return 0;
}
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(0);
	int i, j, m;
	cin >> n >> l >> v1 >> v2 >> k;
	sumd = l*n;
	tempk = (v2 + v1) / (v2 * 2);
	if (n%k == 0)num2 = n / k;
	else num2 = n / k + 1;
	double tl = 0, tr = 1e10;
	check(3.5);
	while (tr - tl >= eps)
	{
		double mid = (tr + tl) / 2;
		if (check(mid))tr = mid;
		else tl = mid;
	}
	cout << setprecision(15) << tl / v2 + (l - tl) / v1;
	return 0;
}


/* Dsingh_24 */

#include<bits/stdc++.h>
#define ll          long long
#define pb          push_back
#define	endl		'\n'
#define pii         pair<ll int,ll int>
#define vi          vector<ll int>
#define all(a)      (a).begin(),(a).end()
#define F           first
#define S           second
#define sz(x)       (ll int)x.size()
#define hell        1000000007
#define rep(i,a,b)	for(ll int i=a;i<b;i++)
#define lbnd        lower_bound
#define ubnd        upper_bound
#define bs          binary_search
#define mp          make_pair
#define ios	    ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
using namespace std;

#define N  200005
ll n,k;
double l,v1,v2;
ll check(double tot){
	double t=((tot*v1-l)/(v1-v2))*1.0l;
	ll c=n/k;
	if(n%k==0)c--;
	double cc=(c*1.0l)*((2.0l*v2)/(v1+v2))*t;
	cc+=t;
	if(tot-cc>0.000000001)return 1;
	return 0;
}
int main()
{
	ios
	ll i,j;
	cin>>n>>l>>v1>>v2>>k;
	double hi=hell,mid,lo=0;
	for(i=0;i<100;i++){
		mid=(hi+lo)/2;
		if(check(mid))
			hi=mid;
		else
			lo=mid;
	}
	cout<<setprecision(12);
	if(check(lo))cout<<lo;else
	cout<<hi;
	return 0;
}


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

#define  int        long long int
 #define    sp(x)                 setprecision(x)
#define    bp(x)           __builtin_popcount(x)
 #define  ld         long double
 #define  f(i,j,n)            for(int i = j; i <= n; i++)
#define  r(i,n,j)       for(int i = n; i >= j; i--)
 #define  all(container)       container.begin() , container.end()
#define  sz(container)   (int)container.size()
 #define  ff             first
#define  ss             second
 #define  pii      pair <int , int>
#define  sp(x)       setprecision(x)
 #define  endl    "\n"
#define  mod   1000000007
 #define  pb    push_back
#define  mp    make_pair
 #define  T     int ttt; cin >> ttt; while(ttt--)
#define fast ios_base::sync_with_stdio(false),cin.tie(NULL),cout.tie(NULL);

int power(int x, int y, int p)
{
    int res = 1;
    x = x % p;
    if (x == 0) return 0;
    while (y > 0)
    {
        if (y & 1)
            res = (res*x) % p;
        y = y>>1;
        x = (x*x) % p;
    }
    return res;
}
ld n,d,v1,v2,k;
bool solve(ld t)
{
    ld l=d;
    for(int i=k;i<n;)
    {
        ld x= l-v1*t;
        x=x/(ld)(v2-v1);
        t-=x;
        l-=x*v1;
        ld y=x*(v2-v1);
        y= y/(v2+v1);
        t-=y;
        l-=y*v1;
        if(t<0.000 )
            return 0;
        i+=k;
    }
    if(l>v2*t)
          return 0;
    return 1;
}

int32_t main()
{
    fast
    cin>>n>>d>>v1>>v2>>k;
    ld l=0.000,r=1e15,ans=0.00;
    f(i,0,300)
    {
        ld m=(l+r)/2.00;
        if(solve(m))
        {
            ans=m;
            r=m;
        }
        else
            l=m;
    }

    cout<<fixed<<sp(10)<<ans;
}


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

typedef long long ll;
typedef long double ld;
#define pb push_back
#define pll pair<ll,ll>
#define vl vector<ll>
#define vll vector < pll >
#define sl set<ll>
#define mll map<ll,ll>
#define itr :: iterator
#define pf push_front
#define ff first
#define ss second
#define stkl stack <ll>
#define quel queue <ll>
#define pquel priority_queue <ll>
#define rep(i,n) for(i=0;i<n;i++)
#define MOD 1000000007
#define SIZE 100005
#define PI 3.14159265358979323846

#define debug(var) cout << "[" << __LINE__ << "] " << #var << " = " << (var) << endl;

struct edge {
    ll A;
    ll B;
};

// Implementation of DSU (Union by Rank)
/*
ll parent[SIZE],rank[SIZE];

ll find_set(ll v) {
    if (v == parent[v])
        return v;
    return parent[v] = find_set(parent[v]);
}

void make_set(ll v) {
    parent[v] = v;
    rank[v] = 0;
}

void union_sets(ll a, ll b) {
    a = find_set(a);
    b = find_set(b);
    if (a != b) {
        if (rank[a] < rank[b])
            swap(a, b);
        parent[b] = a;
        if (rank[a] == rank[b])
            rank[a]++;
    }
}
*/
//*********************************************

ll power(ll a, ll b, ll mod){
    ll x = 1, y = a;
    while (b > 0){
        if (b%2){
            x = (x*y)%mod;
        }
        y = (y*y)%mod;
        b /= 2;
    }
    return x%mod;
}

// FOR FINDING MODULAR INVERSE

ll modular_inverse(ll n, ll mod){
    return power(n, mod-2, mod);
}

// ll bin_search(ll n,ll z,ll beg,ll end){
//     if(beg > end)return -1;
//     ll k = (beg + end) /2;
//     bool c1,c2,c3;

//     c1 = check(k,z,n);
//     c2 = check(k+1,z,n);

//     if(c1 == false && c2 == false){
//         end = k-1;
//     }else if(c1 == true && c2 == false){
//         return k;
//     }else{
//         beg = k+1;
//     }

//     return bin_search(n,z,beg,end);
// }

bool edgecompare(edge lhs, edge rhs) { if(lhs.B!=rhs.B)return lhs.B < rhs.B;
else return lhs.A<rhs.A;}

int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    cout<<setprecision(15);

    ll i,n;
    ld a[SIZE];
    ll l,v1,v2,k;
    cin>>n>>l>>v1>>v2>>k;

    ld lb = ceil((ld)n/k)-1;
    ld x = l/(1+(2*lb*v1/(v1+v2)));

    ld t = (x*(v1-v2)+(l*v2))/(v1*v2);

    cout<<t;
    /*ll n,m,i,j,k,flag=0,x;
    ll *a;//[SIZE];

    cin>>n;
    a = new ll[n];
    rep(i,n)
    {
        cin>>a[i];
    }

    delete a;*/

   return 0;
}


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

typedef long long ll;
typedef long double ld;
#define pb push_back
#define pll pair<ll,ll>
#define vl vector<ll>
#define vll vector < pll >
#define sl set<ll>
#define mll map<ll,ll>
#define itr :: iterator
#define pf push_front
#define ff first
#define ss second
#define stkl stack <ll>
#define quel queue <ll>
#define pquel priority_queue <ll>
#define rep(i,n) for(i=0;i<n;i++)
#define MOD 1000000007
#define SIZE 100005
#define PI 3.14159265358979323846

#define debug(var) cout << "[" << __LINE__ << "] " << #var << " = " << (var) << endl;

struct edge {
    ll A;
    ll B;
};

// Implementation of DSU (Union by Rank)
/*
ll parent[SIZE],rank[SIZE];

ll find_set(ll v) {
    if (v == parent[v])
        return v;
    return parent[v] = find_set(parent[v]);
}

void make_set(ll v) {
    parent[v] = v;
    rank[v] = 0;
}

void union_sets(ll a, ll b) {
    a = find_set(a);
    b = find_set(b);
    if (a != b) {
        if (rank[a] < rank[b])
            swap(a, b);
        parent[b] = a;
        if (rank[a] == rank[b])
            rank[a]++;
    }
}
*/
//*********************************************

ll power(ll a, ll b, ll mod){
    ll x = 1, y = a;
    while (b > 0){
        if (b%2){
            x = (x*y)%mod;
        }
        y = (y*y)%mod;
        b /= 2;
    }
    return x%mod;
}

// FOR FINDING MODULAR INVERSE

ll modular_inverse(ll n, ll mod){
    return power(n, mod-2, mod);
}

// ll bin_search(ll n,ll z,ll beg,ll end){
//     if(beg > end)return -1;
//     ll k = (beg + end) /2;
//     bool c1,c2,c3;

//     c1 = check(k,z,n);
//     c2 = check(k+1,z,n);

//     if(c1 == false && c2 == false){
//         end = k-1;
//     }else if(c1 == true && c2 == false){
//         return k;
//     }else{
//         beg = k+1;
//     }

//     return bin_search(n,z,beg,end);
// }

bool edgecompare(edge lhs, edge rhs) { if(lhs.B!=rhs.B)return lhs.B < rhs.B;
else return lhs.A<rhs.A;}

int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    cout<<setprecision(15);

    ll i,n;
    ld a[SIZE];
    ll l,v1,v2,k;
    cin>>n>>l>>v1>>v2>>k;
    ld lb = ceil(n/k)-1;

    ld x = l/(1+(2*lb*v1/(v1+v2)));

    ld t = (x*(v1-v2)+(l*v2))/(v1*v2);

    cout<<t;
    /*ll n,m,i,j,k,flag=0,x;
    ll *a;//[SIZE];

    cin>>n;
    a = new ll[n];
    rep(i,n)
    {
        cin>>a[i];
    }

    delete a;*/

   return 0;
}


/*input
3 6 1 2 1
*/
#include <bits/stdc++.h>
#include<stdio.h>
using namespace std;
#define F(i,a,b) for(ll i = a; i <= b; i++)
#define RF(i,a,b) for(ll i = a; i >= b; i--)
#define pii pair<ll,ll>
#define PI 3.14159265358979323846264338327950288
#define ll long long
#define ff first
#define ss second
#define pb(x) push_back(x)
#define mp(x,y) make_pair(x,y)
#define debug(x) cout << #x << " = " << x << endl
#define INF 1000000009
#define mod 1000000007
#define S(x) scanf("%d",&x)
#define S2(x,y) scanf("%d%d",&x,&y)
#define P(x) printf("%d\n",x)
#define all(v) v.begin(),v.end()
double v1,v2,k,n,l;
bool check(double mid)
{
	ll numgroups = ceil(n/k);
	double timepassed = 0.0;
	F(i,1,numgroups)
	{
		double x = (l - v1*mid)/(v2-v1);
		timepassed += x;
		if(i+1 <= numgroups) // bring it back
		{
			double y = x*((v2-v1)/(v2+v1));
			timepassed += y;
		}
	}
	if(timepassed > mid)
		return 0;
	return 1;
}
int main()
{
	std::ios::sync_with_stdio(false);
	cin>>n>>l>>v1>>v2>>k;
	double lo = 0.00000000000000;
	double hi = l/v1;
	while(hi - lo > 0.000001)
	{
		double mid = (lo + hi)/2.0;
		if(check(mid))
			hi = mid;
		else
			lo = mid;
	}
	cout<<fixed<<setprecision(12)<<lo<<endl;
	return 0;
}


/*input
3 6 1 2 1
*/
#include <bits/stdc++.h>
#include<stdio.h>
using namespace std;
#define F(i,a,b) for(ll i = a; i <= b; i++)
#define RF(i,a,b) for(ll i = a; i >= b; i--)
#define pii pair<ll,ll>
#define PI 3.14159265358979323846264338327950288
#define ll long long
#define ff first
#define ss second
#define pb(x) push_back(x)
#define mp(x,y) make_pair(x,y)
#define debug(x) cout << #x << " = " << x << endl
#define INF 1000000009
#define mod 1000000007
#define S(x) scanf("%d",&x)
#define S2(x,y) scanf("%d%d",&x,&y)
#define P(x) printf("%d\n",x)
#define all(v) v.begin(),v.end()
double v1,v2,k,n,l;
bool check(double mid)
{
	ll numgroups = ceil(n/k);
	double timepassed = 0.0;
	F(i,1,numgroups)
	{
		double x = (l - v1*mid)/(v2-v1);
		timepassed += x;
		if(i+1 <= numgroups) // bring it back
		{
			double y = x*((v2-v1)/(v2+v1));
			timepassed += y;
		}
		if(timepassed > mid)
			return 0;
	}
	return 1;
}
int main()
{
	std::ios::sync_with_stdio(false);
	cin>>n>>l>>v1>>v2>>k;
	double lo = 0.00000000000000;
	double hi = l/v1;
	while(hi - lo > 0.0000001)
	{
		double mid = (lo + hi)/2.0;
		if(check(mid))
			hi = mid;
		else
			lo = mid;
	}
	cout<<fixed<<setprecision(12)<<lo<<endl;
	return 0;
}


#include <bits/stdc++.h>
using namespace std;
static int n, k, l, v1, v2, a;
bool achieve(double x){
    double good = (a-1)*2*x*v1/(v1 + v2) + x;
    if(good<= l){
        return true;
    }
    return false;
}
int main(){
    cin >> n >> l >> v1 >> v2 >> k;
    a = ceil(((double) n)/k);
    double lo = 0;
    double hi = l;
    while(abs(hi - lo) >= .00000001){
        double m = (lo + hi)/2;
        if(achieve(m)){
            lo = m;
        }
        else{
            hi = m;
        }
    }
    //cout << hi<< endl;
    double time = hi/v2 + (l-hi)/v1;
    cout <<setprecision(100)<< time << endl;
    return 0;
}


#include <bits/stdc++.h>
using namespace std;
static int n, k, l, v1, v2, a;
bool achieve(double x){
    double good = (a-1)*2*x*v1/(v1 + v2) + x;
    if(good<= l){
        return true;
    }
    return false;
}
int main(){
    cin >> n >> l >> v1 >> v2 >> k;
    a = ceil(((double) n)/k);
    double lo = 0;
    double hi = l;
    while(abs(hi - lo) >= .000000000000001){
        double m = (lo + hi)/2;
        if(achieve(m)){
            lo = m;
        }
        else{
            hi = m;
        }
    }
    //cout << hi<< endl;
    double time = hi/v2 + (l-hi)/v1;
    cout <<setprecision(100)<< time << endl;
    return 0;
}


#include<iostream>
#include<algorithm>
#include<iomanip>

using namespace std;

int main()
{
	int n, k;
	double l, v1, v2;
	cin >> n >> l >> v1 >> v2 >> k;
	int num = n / k;
	if (n%k != 0)//可能还要再去接一次
		num++;
	double sub = (v1 + v2)*l / (v1 + v2 + 2 * v1*(num - 1));//每一次乘车的路程
	cout << fixed << setprecision(10) << sub / v2 + (l - sub) / v1;
	return 0;
}


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

int main()
{
	int n, k;
	double l, v1, v2;
	cin >> n >> l >> v1 >> v2 >> k;
	int num = n / k;
	if (n%k != 0)//可能还要再去接一次
		num++;
	double sub = (v1 + v2)*l / (v1 + v2 + 2 * v1*(num - 1));//每一次乘车的路程
	printf("%.7f\n",sub / v2 + (l - sub) / v1);
	return 0;
}


#include<bits/stdc++.h>

using namespace std;

int main()
{
	double l,v1,v2,t1,t2,l2;
	int n,k;
	while(~scanf("%d%lf%lf%lf%d",&n,&l,&v1,&v2,&k))
	{
		int ti = n/k;
		if(ti == 1)
		{
			printf("%.12f\n",(double)l/v2);
			continue;
		}
		ti--;
		l2 = (l*(v1+v2)*v2)/(ti*ti*v1*v2+v2*(v1+v2));
		t2 = l2/v2;
		t1 = (l-l2)/v1;
		printf("%.12f\n",(double)t1+t2);

	}

 return 0;
}


#include <bits/stdc++.h>
#define ws ws1

using namespace std;

typedef long long ll;

ll n, l, ws, bs, k;
double low, high, mid, tp, ans = 1e18;

int main(){
	ios_base::sync_with_stdio(false);
	cin.tie(nullptr);
	cin >> n >> l >> ws >> bs >> k;
	high = 1.0*l / ws;
	//cout << high << " ";
	while(high - low >= 1e-9){
		//cout << mid << "\n";
		mid = (high+low)/2;
		tp = 0;
		//cout << ceil(1.0*n/k) << " ";
		for(int i =0; i < ceil(1.0*n/k); ++i){
			double x, y;
			x = 1.0*(l - mid*ws) / (bs - ws);
			tp += x;
			y = x*(bs - ws) / (bs + ws);
			if(i + 1 == ceil(1.0*n/k)){
				break;
			}
			tp += y;
		}
		if(tp > mid){
			low = mid;
			continue;
		}
		high = mid;
		ans = min(ans, mid);
	}
	cout << setprecision(9) << fixed << ans << "\n";
}


#include <bits/stdc++.h>
#define ws ws1

using namespace std;

typedef long long ll;

ll n, l, ws, bs, k;
double low, high, mid, tp, ans = 1e18;

int main(){
	ios_base::sync_with_stdio(false);
	cin.tie(nullptr);
	cin >> n >> l >> ws >> bs >> k;
	high = 1.0*l / ws;
	int st = 0;
	//cout << high << " ";
	while(st < 60){
		//cout << mid << "\n";
		mid = (high+low)/2;
		tp = 0;
		//cout << ceil(1.0*n/k) << " ";
		for(int i =0; i < ceil(1.0*n/k); ++i){
			double x, y;
			x = 1.0*(l - mid*ws) / (bs - ws);
			tp += x;
			y = x*(bs - ws) / (bs + ws);
			if(i + 1 == ceil(1.0*n/k)){
				break;
			}
			tp += y;
		}
		if(tp > mid){
			low = mid;
			continue;
		}
		high = mid;
		ans = min(ans, mid);
		++st;
	}
	cout << setprecision(9) << fixed << ans << "\n";
}


#include <bits/stdc++.h>
#define ws ws1

using namespace std;

typedef long long ll;

ll n, l, ws, bs, k;
double low, high, mid, tp, ans = 1e18;

int main(){
	ios_base::sync_with_stdio(false);
	cin.tie(nullptr);
	cin >> n >> l >> ws >> bs >> k;
	high = 1.0*l / ws;
	int st = 0;
	//cout << high << " ";
	while(st < 60){
		//cout << mid << "\n";
		mid = (high+low)/2;
		tp = 0;
		//cout << ceil(1.0*n/k) << " ";
		for(int i =0; i < ceil(1.0*n/k); ++i){
			double x, y;
			x = 1.0*(l - mid*ws) / (bs - ws);
			tp += x;
			y = x*(bs - ws) / (bs + ws);
			if(i + 1 == ceil(1.0*n/k)){
				break;
			}
			tp += y;
		}
		if(tp > mid){
			low = mid;
			++st;
			continue;
		}
		high = mid;
		ans = min(ans, mid);
		++st;
	}
	cout << setprecision(9) << fixed << ans << "\n";
}


#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int main()
{
    double n,l,v1,v2,k;
    cin>>n>>l>>v1>>v2>>k;
    double low=0;
    double high=(l/v1);
    int cnt=150;
    double ans=0;
    while(cnt--)
    {
        bool ok=true;
        double pos=0;
        double mid=(low+high)/2;
        double cc=mid;
        double xx=n;
        while(xx>k)
        {
            xx-=k;
            double diff=l-pos;
            double t1=((l-pos)-(v2*mid))/(v1-v2);
            double t2=mid-t1;
            if(t1<0 || t2<0)
            {
                ok=false;
                break;
            }
            double bus_leave=pos+v2*t2;
            pos=pos+v1*t2;
            double gap=bus_leave-pos;
            mid-=t2;
            mid=mid-(gap/(v1+v2));
            pos=pos+(gap/(v1+v2))*v1;

        }
        if((l-pos)>v2*mid)
        {
            ok=false;
        }
        if(ok)
        {
            ans=cc;
            high=cc-0.0001;
        }
        else
        {
            low=cc+0.0001;
        }
    }
    printf("%0.10f",ans);
}


#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int main()
{
    double n,l,v1,v2,k;
    cin>>n>>l>>v1>>v2>>k;
    double low=0;
    double high=(l/v1);
    int cnt=150;
    double ans=0;
    while(cnt--)
    {
        bool ok=true;
        double pos=0;
        double mid=(low+high)/2;
       // cout<<low<<" "<<high<<endl;
        double cc=mid;
        double xx=n;
        while(xx>k)
        {
            xx-=k;
            double diff=l-pos;
            double t1=((l-pos)-(v2*mid))/(v1-v2);
            double t2=mid-t1;
            if(t1<0 || t2<0)
            {
                ok=false;
                break;
            }
            double bus_leave=pos+v2*t2;
            pos=pos+v1*t2;
            double gap=bus_leave-pos;
            mid-=t2;
            mid=mid-(gap/(v1+v2));
            pos=pos+(gap/(v1+v2))*v1;

        }
        if((l-pos)>v2*mid)
        {
            ok=false;
        }
        if(ok)
        {
            ans=cc;
            high=cc-0.0001;
        }
        else
        {
            low=cc+0.0001;
        }
    }
    printf("%0.10f",(low+high)/2);
}


#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int main()
{
    double n,l,v1,v2,k;
    cin>>n>>l>>v1>>v2>>k;
    double low=0;
    double high=(l/v1);
    int cnt=150;
    double ans=0;
    while(cnt--)
    {
        bool ok=true;
        double pos=0;
        double mid=(low+high)/2;
       // cout<<low<<" "<<high<<endl;
        double cc=mid;
        double xx=n;
        while(xx>k)
        {
            xx-=k;
            double diff=l-pos;
            double t1=((l-pos)-(v2*mid))/(v1-v2);
            double t2=mid-t1;
            if(t1<0 || t2<0)
            {
                ok=false;
                break;
            }
            double bus_leave=pos+v2*t2;
            pos=pos+v1*t2;
            double gap=bus_leave-pos;
            mid-=t2;
            mid=mid-(gap/(v1+v2));
            pos=pos+(gap/(v1+v2))*v1;

        }
        if((l-pos)>v2*mid)
        {
            ok=false;
        }
        if(ok)
        {
            ans=cc;
            high=cc;
        }
        else
        {
            low=cc;
        }
    }
    printf("%0.10f",ans);
}


#include<bits/stdc++.h>
#define fi first
#define se second
#define pb push_back
#define mk make_pair
#define pii pair<int,int>
#define read(x) scanf("%d",&x)
#define dread(x) scanf("%lf",&x)
#define lread(x) scanf("%lld",&x)
using namespace std;

typedef long long ll;
const int N=2e5+7;
const int mod=1e9+7;
const int base=17;
const int inf=0x3f3f3f3f;
const ll INF=0x3f3f3f3f3f3f3f3f;

int n,k;
double v1,v2,l;
bool check(double T)
{
    double x=(T-l/v1)*v1*v2/(v1-v2);
    //printf("%.3f %.3f\n",T,x);
    if(x<=0) return true;
    if(x>l) return false;
    int all=n,t=0;
    double pos=0;
    while(all)
    {
        if(t>T) return false;
        all-=min(k,all);
        double pos2=pos+x;
        if(pos2>l) return false;
        double t1=x/v2;
        pos+=t1*v1;
        double t2=(pos2-pos)/(v1+v2);
        pos+=t2*v1;
        t+=t1+t2;
    }
    return true;
}
int main()
{
    read(n); dread(l);
    dread(v1); dread(v2); read(k);
    double L=l/v2,R=l/v1,ans=0;
    for(int i=1;i<=64;i++)
    {
        double mid=(L+R)/2;
        if(check(mid))
            ans=mid,R=mid;
        else L=mid;
    }
    printf("%.12f\n",ans);
    return 0;
}
/*
x/v2+(l-x)/v1==T
x/v2+l/v1-x/v1==T
x/v2-x/v1==T-l/v1
x=(T-l/v1)*v1*v2/(v1-v2);

*/


#include <bits/stdc++.h>
using namespace std;
typedef long double LD;
int main(){
	int n, v1, v2, k;
	LD l, l2;
	scanf("%d%Lf%d%d%d", &n, &l, &v1, &v2, &k);
	int m = n;
	l2 = l;

	LD lo = 0, hi = l/v1, ans = 0;
	for(int i=0;i<150;i++){
		LD mid = (lo+hi)/2;
		n = m;
		l = l2;
		LD t = 0;
		bool ok = 1;
		while(n > 0){
			int mn = min(n, k);
			n -= mn;

			LD t2 = ( l - v1*(mid-t) ) / (v2-v1);
			LD t1 = (mid-t) - t2;

			if(t2 < 0){
				ok = 0;
				break;
			}

			t += t2;
			if(t > mid){
				ok = 0;
				break;
			}
			if(n > 0){

				LD d = t2*v2 - t2*v1;

				LD use = d/(v1+v2);

				l -= (t2+use)*v1;
				t += use;
				if(t > mid){
					ok = 0;
					break;
				}
			}
		}
		if(ok) ans = mid, hi = mid;
		else lo = mid;
	}

	printf("%.20Lf\n", ans);
}


#include<bits/stdc++.h>
using namespace std;
int main()
{
    int n,l,v1,v2,k;
    scanf("%d%d%d%d%d",&n,&l,&v1,&v2,&k);
    int cnt=n/k;
    if(n%k)
        cnt++;
    double fenzi= (double)l*(v1+v2);
    double fenmu = (double)(2*v1*(cnt-1)+v1+v2);
    double l1=fenzi/fenmu;
    double ans=(l1/v2)+(double(l-l1)/v1);
    printf("%.12lf\n",ans);
    return 0;
}


#include <bits/stdc++.h>
using namespace std;
const int N = 1e5+5;
int n,k;
double v1,v2,l,r,m;
bool check(double t) {
    double t2=(m-v1*t)/(v2-v1);
    double t3=(v2-v1)*t2/(v2+v1);
    int g=(n+k-1)/k;
    double ans=t2*g+t3*(g-1);
    return ans<=t;
}
int main() {
    cin>>n>>m>>v1>>v2>>k;
    l=m/v2;
    r=m/v1;
    for (int i=1; i<=10000; i++) {
        double mid=(l+r)/2;
        if (check(mid)) r=mid;
        else l=mid;
    }
    printf("%.10f\n",r);

    return 0;
}


#include<bits/stdc++.h>
#define F first
#define S second
#define PB push_back
#define MP make_pair
#define LB lower_bound
#define UB upper_bound
#define SP fixed << setprecision(10)
#define int long double
using namespace std;

typedef long long ll;
typedef pair <int, int> pii;
typedef long double DB;
DB n , l , v1 , v2 , k;
bool check(DB sec , int num , DB len){

	if(!num)
	   return 1;
	if(v2*sec > len)
	   return 0;

	DB tmp = (v2*sec - v1*sec)/(v1 + v2);
	return check(sec , max((DB) 0 , num - k) , len-v1*sec - tmp*v1);
}

main(){

	ios_base::sync_with_stdio(0) , cin.tie(0) , cout.tie(0);

	DB st = 0.0 , en;
	cin >> n >> l >> v1 >> v2 >> k;
	en = l + 1;

	for(int i = 0 ; i < 500 ; i++){
	   DB mid = (st + en)/2;
	   if(check(mid , n , l))
		  st = mid;
	   else
		  en = mid;
	}

	DB tmp = l - (DB) v2*st;
	cout << SP << st + tmp/(DB) v1 << endl;

	return 0;
}


 #include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <list>
#include <queue>
#include <string>
#include <vector>
#include <set>
#include <sstream>
#include <cstdio>
#include <cstring>
#include <stack>
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
typedef pair<long long,long long> pll;
typedef vector<vector<int>> vvi;
typedef vector<vector<int>> vi;
typedef pair<pair<int,int>, int> ppiii;
typedef pair<int, pair<int,int>> pipii;
typedef pair<int,char> pic;
typedef pair<char,int> pci;
typedef pair<string,string> pss;

const double MX = 2000000000;
int n,k;
double l, v1, v2;
double findDrop(double l, double vbus, double vn, double time_left) {
	double beg = 0;
	double end = l;
	double result = -1;
	//cout << "input is " << l << " " << time_left << " " << vn << " " << vbus<< endl;
	for (int i = 0; i < 40; i++) {
		double mid = (beg + end) / 2;
		double tot = mid / vbus;
		tot += (l-mid) / vn;
		//cout << "mid and tot is " << mid << " " << tot << " " << endl;
		if (tot <= time_left) {
			end = mid;
			result = mid;
		} else {
			beg = mid;
		}
	}
	return result;
}
bool fine(double time_left) {
    double curpos = l;
    int left = n;
    while(left > 0) {
        if (time_left < 0) return false;
        double X = findDrop(curpos, v2, v1, time_left);
        double pupil = X - ((X/v2) * v1);
        double time_loss = (X / v2) + (pupil / (v1+v2));
        time_left -= time_loss;
        curpos -= (v1 * time_loss);
        //cout << "X time loss is " << X << " " << time_loss << " " << curpos << endl << endl;
        left -= k;
        if (X == -1) return false;
    }
    return true;
}
int main() {
  ios_base::sync_with_stdio(0);
  cin.tie(0);

  cin >> n >> l >> v1>>v2>>k;
  double result = l / v1;

  double beg = 0;
  double end = result;
  for (int i = 1; i <= 60; i++) {
      double mid = (beg + end) / (double)2;
      //cout << mid << " " << fine(mid) << endl;
      if (fine(mid)) {
          end = mid;
          result = min(result, mid);
      } else {
          beg = mid;
      }
  }

  cout.precision(17);
  std::cout << fixed  << result;
  //cout << fine(4.7);

}


 #include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <list>
#include <queue>
#include <string>
#include <vector>
#include <set>
#include <sstream>
#include <cstdio>
#include <cstring>
#include <stack>
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
typedef pair<long long,long long> pll;
typedef vector<vector<int>> vvi;
typedef vector<vector<int>> vi;
typedef pair<pair<int,int>, int> ppiii;
typedef pair<int, pair<int,int>> pipii;
typedef pair<int,char> pic;
typedef pair<char,int> pci;
typedef pair<string,string> pss;

const double MX = 2000000000;
int n,k;
double l, v1, v2;
double findDrop(double l, double vbus, double vn, double time_left) {
	double beg = 0;
	double end = l;
	double result = -1;
	//cout << "input is " << l << " " << time_left << " " << vn << " " << vbus<< endl;
	for (int i = 0; i < 60; i++) {
		double mid = (beg + end) / 2;
		double tot = mid / vbus;
		tot += (l-mid) / vn;
		//cout << "mid and tot is " << mid << " " << tot << " " << endl;
		if (tot <= time_left) {
			end = mid;
			result = mid;
		} else {
			beg = mid;
		}
	}
	return result;
}
bool fine(double time_left) {
    double curpos = l;
    int left = n;
    while(left > 0) {
        if (time_left < 0) return false;
        double X = findDrop(curpos, v2, v1, time_left);
        double pupil = X - ((X/v2) * v1);
        double time_loss = (X / v2) + (pupil / (v1+v2));
        time_left -= time_loss;
        curpos -= (v1 * time_loss);
        //cout << "X time loss is " << X << " " << time_loss << " " << curpos << endl << endl;
        left -= k;
        if (X == -1) return false;
    }
    return true;
}
int main() {
  ios_base::sync_with_stdio(0);
  cin.tie(0);

  cin >> n >> l >> v1>>v2>>k;
  double result = l / v1;

  double beg = 0;
  double end = result;
  for (int i = 1; i <= 60; i++) {
      double mid = (beg + end) / (double)2;
      //cout << mid << " " << fine(mid) << endl;
      if (fine(mid)) {
          end = mid;
          result = min(result, mid);
      } else {
          beg = mid;
      }
  }

  cout.precision(17);
  std::cout << fixed  << result;
  //cout << fine(4.7);

}


#include <iostream>
#include <fstream>
#include <string>
#include <iomanip>
#include <bitset>
#include <vector>
#include <math.h>
#include <queue>
#include <map>
#include <set>
#include <list>
#include <time.h>
#include <algorithm>
#define mkp make_pair
#define inf 1000000000000000000
#define MOD 1000000007
#define eps 1e-8

using namespace std;
typedef long long ll;

int n,k;
double l,v1,v2;

double solve(double t)
{
    double m=n/k+(n%k!=0);
    m=m-1;
    double dist=2*m*t*((v1*v2)/(v2+v1));
    if(dist<l-t*v2)
        return t+(l-t*v2)/v1;
}

int main()
{
    ios_base::sync_with_stdio(0);
    cin>>n>>l>>v1>>v2>>k;
    double l=0,r=2000000000;
    double m1,m2;
    while(r-l>eps)
    {
        m1=l+(r-l)/3;
        m2=m1+(r-l)/3;
        if(solve(m1)>=solve(m2))
            l=m1;
        else
            r=m2;
    }
    cout<<fixed<<setprecision(12);
    cout<<solve(l)<<endl;
}


#include <iostream>
#include <fstream>
#include <string>
#include <iomanip>
#include <bitset>
#include <vector>
#include <math.h>
#include <queue>
#include <map>
#include <set>
#include <list>
#include <time.h>
#include <algorithm>
#define mkp make_pair
#define inf 1000000000000000000
#define MOD 1000000007
#define eps 1e-12

using namespace std;
typedef long long ll;

int n,k;
long double l,v1,v2;

long double solve(long double t)
{
    long double m=n/k+(n%k!=0);
    m=m-1;
    long double dist=2*m*t*((v1*v2)/(v2+v1));
    if(dist<l-t*v2)
        return t+(l-t*v2)/v1;
}

int main()
{
    ios_base::sync_with_stdio(0);
    cin>>n>>l>>v1>>v2>>k;
    long double l=0,r=1000000000;
    long double m1,m2;
    while(r-l>eps)
    {
        m1=l+(r-l)/3;
        m2=m1+(r-l)/3;
        if(solve(m1)>=solve(m2))
            l=m1;
        else
            r=m2;
    }
    cout<<fixed<<setprecision(12);
    cout<<solve(l)<<endl;
}


#include <iostream>
#include <fstream>
#include <string>
#include <iomanip>
#include <bitset>
#include <vector>
#include <math.h>
#include <queue>
#include <map>
#include <set>
#include <list>
#include <time.h>
#include <algorithm>
#define mkp make_pair
#define inf 1000000000000000000
#define MOD 1000000007
#define eps 1e-14

using namespace std;
typedef long long ll;

int n,k;
long double l,v1,v2;

long double solve(long double t)
{
    long double m=n/k+(n%k!=0);
    m=m-1;
    long double dist=2*m*t*((v1*v2)/(v2+v1));
    if(dist<l-t*v2)
        return t+(l-t*v2)/v1;
}

int main()
{
    ios_base::sync_with_stdio(0);
    cin>>n>>l>>v1>>v2>>k;
    long double l=0,r=1000000000;
    long double m1,m2;
    while(r-l>eps)
    {
        m1=l+(r-l)/3;
        m2=m1+(r-l)/3;
        if(solve(m1)>=solve(m2))
            l=m1;
        else
            r=m2;
    }
    cout<<fixed<<setprecision(12);
    cout<<solve(l)<<endl;
}


#include <iostream>
#include <fstream>
#include <string>
#include <iomanip>
#include <bitset>
#include <vector>
#include <math.h>
#include <queue>
#include <map>
#include <set>
#include <list>
#include <time.h>
#include <algorithm>
#define mkp make_pair
#define inf 1000000000000000000
#define MOD 1000000007
#define eps 1e-9

using namespace std;
typedef long long ll;

int n,k;
double l,v1,v2;

double solve(double t)
{
    double m=n/k+(n%k!=0);
    m--;
    double dist=m*t*v1*(2*v2/(v2+v1));
    if(dist<l-t*v2)
        return t+(l-t*v2)/v1;
}

int main()
{
    ios_base::sync_with_stdio(0);
    cin>>n>>l>>v1>>v2>>k;
    double l=0,r=1000000000;
    double m1,m2;
    while(r-l>eps)
    {
        m1=l+(r-l)/3;
        m2=m1+(r-l)/3;
        if(solve(m1)>solve(m2))
            l=m1;
        else
            r=m2;
    }
    cout<<fixed<<setprecision(9);
    cout<<solve(m1)<<endl;
}


#include <iostream>
#include <fstream>
#include <string>
#include <iomanip>
#include <bitset>
#include <vector>
#include <math.h>
#include <queue>
#include <map>
#include <set>
#include <list>
#include <time.h>
#include <algorithm>
#define mkp make_pair
#define inf 1000000000000000000
#define MOD 1000000007
#define eps 1e-9

using namespace std;
typedef long long ll;

int n,k;
double l,v1,v2;

double solve(double t)
{
    double m=n/k+(n%k!=0);
    m=m-1;
    double dist=2*m*t*((v1*v2)/(v2+v1));
    if(dist<l-t*v2)
        return t+(l-t*v2)/v1;
}

int main()
{
    ios_base::sync_with_stdio(0);
    cin>>n>>l>>v1>>v2>>k;
    double l=0,r=1000000000;
    double m1,m2;
    while(r-l>eps)
    {
        m1=l+(r-l)/3;
        m2=m1+(r-l)/3;
        if(solve(m1)>=solve(m2))
            l=m1;
        else
            r=m2;
    }
    cout<<fixed<<setprecision(10);
    cout<<solve(l)<<endl;
}


#include <iostream>
#include <fstream>
#include <string>
#include <iomanip>
#include <bitset>
#include <vector>
#include <math.h>
#include <queue>
#include <map>
#include <set>
#include <list>
#include <time.h>
#include <algorithm>
#define mkp make_pair
#define inf 1000000000000000000
#define MOD 1000000007
#define eps 1e-12

using namespace std;
typedef long long ll;

int n,k;
double l,v1,v2;

double solve(double t)
{
    double m=n/k+(n%k!=0);
    m=m-1;
    double dist=2*m*t*((v1*v2)/(v2+v1));
    if(dist<l-t*v2)
        return t+(l-t*v2)/v1;
}

int main()
{
    ios_base::sync_with_stdio(0);
    cin>>n>>l>>v1>>v2>>k;
    double l=0,r=2000000000;
    double m1,m2;
    while(r-l>eps)
    {
        m1=l+(r-l)/3;
        m2=m1+(r-l)/3;
        if(solve(m1)>=solve(m2))
            l=m1;
        else
            r=m2;
    }
    cout<<fixed<<setprecision(12);
    cout<<solve(l)<<endl;
}


#include <iostream>
#include <fstream>
#include <string>
#include <iomanip>
#include <bitset>
#include <vector>
#include <math.h>
#include <queue>
#include <map>
#include <set>
#include <list>
#include <time.h>
#include <algorithm>
#define mkp make_pair
#define inf 1000000000000000000
#define MOD 1000000007
#define eps 1e-12

using namespace std;
typedef long long ll;

int n,k;
long double l,v1,v2;

long double solve(long double t)
{
    long double m=n/k+(n%k!=0);
    m=m-1;
    long double dist=2*m*t*((v1*v2)/(v2+v1));
    if(dist<l-t*v2)
        return t+(l-t*v2)/v1;
}

int main()
{
    ios_base::sync_with_stdio(0);
    int tm=clock();
    cin>>n>>l>>v1>>v2>>k;
    cout<<fixed<<setprecision(12);
    if(k>=n)
    {
        cout<<l/v2<<endl;
        return 0;
    }
    long double l=0,r=1000000000;
    long double m1,m2;
    while(clock()-tm<850)
    {
        m1=l+(r-l)/3;
        m2=m1+(r-l)/3;
        if(solve(m1)>=solve(m2))
            l=m1;
        else
            r=m2;
    }
    cout<<solve(l)<<endl;
}


#include <iostream>
#include <fstream>
#include <string>
#include <iomanip>
#include <bitset>
#include <vector>
#include <math.h>
#include <queue>
#include <map>
#include <set>
#include <list>
#include <time.h>
#include <algorithm>
#define mkp make_pair
#define inf 1000000000000000000
#define MOD 1000000007
#define eps 1e-12

using namespace std;
typedef long long ll;

int n,k;
long double l,v1,v2;

long double solve(long double t)
{
    long double m=n/k+(n%k!=0);
    m=m-1;
    long double dist=2*m*t*((v1*v2)/(v2+v1));
    if(dist<l-t*v2)
        return t+(l-t*v2)/v1;
}

int main()
{
    ios_base::sync_with_stdio(0);
    cin>>n>>l>>v1>>v2>>k;
    cout<<fixed<<setprecision(12);
    if(k>=n)
    {
        cout<<l/v2<<endl;
        return 0;
    }
    long double l=0,r=1000000000;
    long double m1,m2;
    while(r-l>eps)
    {
        m1=l+(r-l)/3;
        m2=m1+(r-l)/3;
        if(solve(m1)>=solve(m2))
            l=m1;
        else
            r=m2;
    }
    cout<<solve(l)<<endl;
}


#include <iostream>
#include <fstream>
#include <string>
#include <iomanip>
#include <bitset>
#include <vector>
#include <math.h>
#include <queue>
#include <map>
#include <set>
#include <list>
#include <time.h>
#include <algorithm>
#define mkp make_pair
#define inf 1000000000000000000
#define MOD 1000000007
#define eps 1e-7

using namespace std;
typedef long long ll;

int n,k;
double l,v1,v2;

double solve(double t)
{
    double m=n/k+(n%k!=0);
    m=m-1;
    double dist=2*m*t*((v1*v2)/(v2+v1));
    if(dist<l-t*v2)
        return t+(l-t*v2)/v1;
}

int main()
{
    ios_base::sync_with_stdio(0);
    cin>>n>>l>>v1>>v2>>k;
    double l=0,r=2000000000;
    double m1,m2;
    while(abs(solve(r)-solve(l))>eps)
    {
        m1=l+(r-l)/3;
        m2=m1+(r-l)/3;
        if(solve(m1)>=solve(m2))
            l=m1;
        else
            r=m2;
    }
    cout<<fixed<<setprecision(12);
    cout<<solve(l)<<endl;
}


#include <iostream>
#include <fstream>
#include <string>
#include <iomanip>
#include <bitset>
#include <vector>
#include <math.h>
#include <queue>
#include <map>
#include <set>
#include <list>
#include <time.h>
#include <algorithm>
#define mkp make_pair
#define inf 1000000000000000000
#define MOD 1000000007
#define eps 1e-10

using namespace std;
typedef long long ll;

int n,k;
long double l,v1,v2;

long double solve(long double t)
{
    long double m=n/k+(n%k!=0);
    m=m-1;
    long double dist=2*m*t*((v1*v2)/(v2+v1));
    if(dist<l-t*v2)
        return t+(l-t*v2)/v1;
}

int main()
{
    ios_base::sync_with_stdio(0);
    cin>>n>>l>>v1>>v2>>k;
    long double l=0,r=1000000000;
    long double m1,m2;
    while(r-l>eps)
    {
        m1=l+(r-l)/3;
        m2=m1+(r-l)/3;
        if(solve(m1)>=solve(m2))
            l=m1;
        else
            r=m2;
    }
    cout<<fixed<<setprecision(12);
    cout<<solve(l)<<endl;
}


#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <stack>
#include <tuple>
#include <queue>

#define for_each(name, left, right) for (int name = left; name < right; name++)
#define show(x) cerr << #x << " = " << x << endl;

using namespace std;

typedef pair<int, int> pii;
typedef long long ll;

bool check(int students_left, double dist_left, double v_st, double v_bus, double time_left) {
    double bus_pos, students_pos;
    bus_pos = 0;
    students_pos = 0;
    while (1) {
        double t = dist_left - v_st * time_left;
        // cout << "**" << t << " " << time_left << endl;
        t /= (v_bus - v_st);
        if (t <= 0) {
            return true;
        }
        else if (t > time_left) {
            return false;
        }
        else if (students_left == 1) {
            return true;
        }
        time_left -= t;
        students_left -= 1;
        dist_left -= t * v_st;
        bus_pos += t * v_bus;
        students_pos += t * v_st;
        t = bus_pos - students_pos;
        t /= v_st + v_bus;
        time_left -= t;
        dist_left -= t * v_st;
        bus_pos -= t * v_bus;
        students_pos += t * v_st;
        if (time_left <= 0) {
            return false;
        }
    }
}

void solve() {
    int students_nr, dist, v_st, v_bus, students_per_bus;
    cin >> students_nr >> dist >> v_st >> v_bus >> students_per_bus;
    students_nr = students_nr + students_per_bus - 1;
    students_nr /= students_per_bus;
    double l = 0;
    double r = 1e+9;
    double eps = 1e-8;
    // cout << check(students_nr, dist, v_st, v_bus, 7) << endl;
    while (r - l > eps) {
        double m = (r + l) / 2;
        // cout << l << " " << m << " " << r << endl;
        if (check(students_nr, dist, v_st, v_bus, m)) {
            r = m;
        }
        else {
            l = m;
        }
    }
    cout.precision(16);
    cout << r << endl;
}

int main() {
    ios_base::sync_with_stdio(0);
    solve();
}


#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <stack>
#include <tuple>
#include <queue>

#define for_each(name, left, right) for (int name = left; name < right; name++)
#define show(x) cerr << #x << " = " << x << endl;

using namespace std;

typedef pair<int, int> pii;
typedef long long ll;

bool check(int students_left, double dist_left, double v_st, double v_bus, double time_left) {
    double bus_pos, students_pos;
    bus_pos = 0;
    students_pos = 0;
    while (1) {
        double t = dist_left - v_st * time_left;
        // cout << "**" << t << " " << time_left << endl;
        t /= (v_bus - v_st);
        if (t <= 0) {
            return true;
        }
        else if (t > time_left) {
            return false;
        }
        else if (students_left == 1) {
            return true;
        }
        time_left -= t;
        students_left -= 1;
        dist_left -= t * v_st;
        bus_pos += t * v_bus;
        students_pos += t * v_st;
        t = bus_pos - students_pos;
        t /= v_st + v_bus;
        time_left -= t;
        dist_left -= t * v_st;
        bus_pos -= t * v_bus;
        students_pos += t * v_st;
        if (time_left <= 0) {
            return false;
        }
    }
}

void solve() {
    int students_nr, dist, v_st, v_bus, students_per_bus;
    cin >> students_nr >> dist >> v_st >> v_bus >> students_per_bus;
    students_nr = students_nr + students_per_bus - 1;
    students_nr /= students_per_bus;
    double l = 0;
    double r = 1e+9;
    double eps = 1e-6;
    // cout << check(students_nr, dist, v_st, v_bus, 7) << endl;
    while (r - l > eps) {
        double m = (r + l) / 2;
        // cout << l << " " << m << " " << r << endl;
        if (check(students_nr, dist, v_st, v_bus, m)) {
            r = m;
        }
        else {
            l = m;
        }
    }
    cout.precision(16);
    cout << r << endl;
}

int main() {
    ios_base::sync_with_stdio(0);
    solve();
}


#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp> // Common file
#include <ext/pb_ds/tree_policy.hpp> // Including tree_order_statistics_node_update

using namespace std;
using namespace __gnu_pbds;

//data structure (fenwick substitute)
template <typename T>
using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;

#define pb push_back
#define eb emplace_back
#define mp make_pair
#define pii pair<int, int>
#define vi vector<int>
#define pll pair<ll, ll>
#define fi first
#define se second
#define ull uint64_t
#define ll int64_t

//debugging snippets
#define Local freopen("input","r",stdin)
#define tr1(x)                cerr << #x << ": " << x << endl;
#define tr2(x, y)             cerr << #x << ": " << x << " | " << #y << ": " << y << endl;
#define tr3(x, y, z)          cerr << #x << ": " << x << " | " << #y << ": " << y << " | " << #z << ": " << z << endl;
#define tr4(a, b, c, d)       cerr << #a << ": " << a << " | " << #b << ": " << b << " | " << #c << ": " << c << " | " << #d << ": " << d << endl;

int n;
double l, v1, v2, k;

bool solve(double dt, double bus_offset, double time_limit) {
    //dt+dx/v2+(len-dx-dt*v1)/v1 <= time_limit
    //dt-time_limit+len/v1-dt<=dx(1/v1-1/v2)
    double dx = (l / v1 - time_limit) / (1 / v1 - 1 / v2);
    int which = n - 1;
    while (which--) {
        double ext = bus_offset / (v1 + v2);
        dt += ext;
        double len = l - dt * v1;
        if (dx > len) return 0;
        if (which == 0) return dt + len / v2 <= time_limit;
        double tdt = dx / v2;
        dt += tdt;
        bus_offset = dx - tdt * v1;
    }
    //unused
    return 1;
}

int main() {
    cin >> n >> l >> v1 >> v2 >> k;
    n = (n + k - 1) / k;
    double ans;
    if (n == 1) ans = l / v2;
    else {
        double lb = 0, ub = l;
        while (ub - lb > 1e-3) {
            double dx = (lb + ub) / 2.0;
            double dt = dx / v2;
            double tim = dt + (l - dx) / v1;
            if (solve(dt, dx - dt * v1, tim)) {
                lb = dx;
            } else ub = dx;
        }
        ans = lb / v2 + (l - lb) / v1;
    }
    cout << setprecision(8) << fixed;
    cout << ans << '\n';
    return 0;
}


#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp> // Common file
#include <ext/pb_ds/tree_policy.hpp> // Including tree_order_statistics_node_update

using namespace std;
using namespace __gnu_pbds;

//data structure (fenwick substitute)
template <typename T>
using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;

#define pb push_back
#define eb emplace_back
#define mp make_pair
#define pii pair<int, int>
#define vi vector<int>
#define pll pair<ll, ll>
#define fi first
#define se second
#define ull uint64_t
#define ll int64_t

//debugging snippets
#define Local freopen("input","r",stdin)
#define tr1(x)                cerr << #x << ": " << x << endl;
#define tr2(x, y)             cerr << #x << ": " << x << " | " << #y << ": " << y << endl;
#define tr3(x, y, z)          cerr << #x << ": " << x << " | " << #y << ": " << y << " | " << #z << ": " << z << endl;
#define tr4(a, b, c, d)       cerr << #a << ": " << a << " | " << #b << ": " << b << " | " << #c << ": " << c << " | " << #d << ": " << d << endl;

int n;
double l, v1, v2, k;

bool solve(double time_limit) {
    //dt+dx/v2+(len-dx-dt*v1)/v1 <= time_limit
    //dt-time_limit+len/v1-dt<=dx(1/v1-1/v2)
    double bus_offset = 0;
    double dx = (l / v1 - time_limit) / (1 / v1 - 1 / v2);
    double dt = 0;
    for (int i = 0; i < n; ++i) {
        double ext = bus_offset / (v1 + v2);
        dt += ext;
        double len = l - dt * v1;
        if (dx > len) return 0;
        if (i == n - 1) break;
        double tdt = dx / v2;
        dt += tdt;
        bus_offset = dx - tdt * v1;
    }
    //unused
    return 1;
}

int main() {
    cin >> n >> l >> v1 >> v2 >> k;
    n = (n + k - 1) / k;
    double lb = 0, ub = l / v1;
    while (ub - lb > 1e-6) {
        double mid = (lb + ub) / 2.0;
        if (solve(mid)) {
            ub = mid;
        } else lb = mid;
    }
    cout << setprecision(8) << fixed;
    cout << lb << '\n';
    return 0;
}


#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp> // Common file
#include <ext/pb_ds/tree_policy.hpp> // Including tree_order_statistics_node_update

using namespace std;
using namespace __gnu_pbds;

//data structure (fenwick substitute)
template <typename T>
using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;

#define pb push_back
#define eb emplace_back
#define mp make_pair
#define pii pair<int, int>
#define vi vector<int>
#define pll pair<ll, ll>
#define fi first
#define se second
#define ull uint64_t
#define ll int64_t

//debugging snippets
#define Local freopen("input","r",stdin)
#define tr1(x)                cerr << #x << ": " << x << endl;
#define tr2(x, y)             cerr << #x << ": " << x << " | " << #y << ": " << y << endl;
#define tr3(x, y, z)          cerr << #x << ": " << x << " | " << #y << ": " << y << " | " << #z << ": " << z << endl;
#define tr4(a, b, c, d)       cerr << #a << ": " << a << " | " << #b << ": " << b << " | " << #c << ": " << c << " | " << #d << ": " << d << endl;
int n;
double l, v1, v2, k;

double solve(double dt, int which, double bus_pos = 0, double time_limit = 0) {
    double len = l - dt * v1;
    if (which != n) {
        double ext = (bus_pos - dt * v1) / (v1 + v2);
        dt += ext;
        len -= ext * v1;
    }
    if (which == 1) return dt + len / v2;
    if (which < n) {
        //dt+dx/v2+(len-dx-dt*v1)/v1 <= time_limit
        //dt-time_limit+len/v1-dt<=dx(1/v1-1/v2)
        double dx = (l / v1 - time_limit) / (1 / v1 - 1 / v2);
        if (dx > len) return 1e18;
        double ddt = dx / v2;
        return solve(dt + ddt, which - 1, dt * v1 + dx, time_limit);
    }
    double l = 0, h = len;
    while (h - l > 1e-10) {
        double dx = (l + h) / 2.0;
        double ddt = dx / v2;
        double tim = dt + ddt + (len - dx) / v1;
        double v = solve(dt + ddt, which - 1, dt * v1 + dx, tim);
        if (v <= tim) {
            l = dx;
        } else h = dx;
    }
    return dt + h / v2 + (len - h) / v1;
}

int main() {
    cin >> n >> l >> v1 >> v2 >> k;
    n = (n + k - 1) / k;
    double ans = solve(0, n);
    cout << setprecision(8) << fixed;
    cout << ans << '\n';
    return 0;
}


#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp> // Common file
#include <ext/pb_ds/tree_policy.hpp> // Including tree_order_statistics_node_update

using namespace std;
using namespace __gnu_pbds;

//data structure (fenwick substitute)
template <typename T>
using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;

#define pb push_back
#define eb emplace_back
#define mp make_pair
#define pii pair<int, int>
#define vi vector<int>
#define pll pair<ll, ll>
#define fi first
#define se second
#define ull uint64_t
#define ll int64_t

//debugging snippets
#define Local freopen("input","r",stdin)
#define tr1(x)                cerr << #x << ": " << x << endl;
#define tr2(x, y)             cerr << #x << ": " << x << " | " << #y << ": " << y << endl;
#define tr3(x, y, z)          cerr << #x << ": " << x << " | " << #y << ": " << y << " | " << #z << ": " << z << endl;
#define tr4(a, b, c, d)       cerr << #a << ": " << a << " | " << #b << ": " << b << " | " << #c << ": " << c << " | " << #d << ": " << d << endl;

int n;
double l, v1, v2, k;

bool solve(double dt, double bus_offset, double time_limit) {
    //dt+dx/v2+(len-dx-dt*v1)/v1 <= time_limit
    //dt-time_limit+len/v1-dt<=dx(1/v1-1/v2)
    double dx = (l / v1 - time_limit) / (1 / v1 - 1 / v2);
    int which = n - 1;
    while (which--) {
        double ext = bus_offset / (v1 + v2);
        dt += ext;
        double len = l - dt * v1;
        if (dx > len) return 0;
        if (which == 0) return dt + len / v2 <= time_limit;
        double tdt = dx / v2;
        dt += tdt;
        bus_offset = dx - tdt * v1;
    }
    //unused
    return 1;
}

int main() {
    cin >> n >> l >> v1 >> v2 >> k;
    n = (n + k - 1) / k;
    double ans;
    if (n == 1) ans = l / v2;
    else {
        double lb = 0, ub = l;
        while (ub - lb > 1e-10) {
            double dx = (lb + ub) / 2.0;
            double dt = dx / v2;
            double tim = dt + (l - dx) / v1;
            if (solve(dt, dx - dt * v1, tim)) {
                lb = dx;
            } else ub = dx;
        }
        ans = lb / v2 + (l - lb) / v1;
    }
    cout << setprecision(8) << fixed;
    cout << ans << '\n';
    return 0;
}


#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp> // Common file
#include <ext/pb_ds/tree_policy.hpp> // Including tree_order_statistics_node_update

using namespace std;
using namespace __gnu_pbds;

//data structure (fenwick substitute)
template <typename T>
using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;

#define pb push_back
#define eb emplace_back
#define mp make_pair
#define pii pair<int, int>
#define vi vector<int>
#define pll pair<ll, ll>
#define fi first
#define se second
#define ull uint64_t
#define ll int64_t

//debugging snippets
#define Local freopen("input","r",stdin)
#define tr1(x)                cerr << #x << ": " << x << endl;
#define tr2(x, y)             cerr << #x << ": " << x << " | " << #y << ": " << y << endl;
#define tr3(x, y, z)          cerr << #x << ": " << x << " | " << #y << ": " << y << " | " << #z << ": " << z << endl;
#define tr4(a, b, c, d)       cerr << #a << ": " << a << " | " << #b << ": " << b << " | " << #c << ": " << c << " | " << #d << ": " << d << endl;
int n;
double l, v1, v2, k;

double solve(double dt, int which, double bus_pos = 0) {
    double len = l - dt * v1;
    if (which != n) {
        double ext = (bus_pos - dt * v1) / (v1 + v2);
        dt += ext;
        len -= ext * v1;
    }
    if (which == 1) return dt + len / v2;
    double l = 0, h = len;
    while (h - l > 1e-10) {
        double dx = (l + h) / 2.0;
        double ddt = dx / v2;
        double tim = dt + ddt + (len - dx) / v1;
        double v = solve(dt + ddt, which - 1, dt * v1 + dx);
        if (v <= tim) {
            l = dx;
        } else h = dx;
    }
    return dt + h / v2 + (len - h) / v1;
}

int main() {
    cin >> n >> l >> v1 >> v2 >> k;
    n = (n + k - 1) / k;
    double ans = solve(0, n);
    cout << setprecision(8) << fixed;
    cout << ans << '\n';
    return 0;
}


#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp> // Common file
#include <ext/pb_ds/tree_policy.hpp> // Including tree_order_statistics_node_update

using namespace std;
using namespace __gnu_pbds;

//data structure (fenwick substitute)
template <typename T>
using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;

#define pb push_back
#define eb emplace_back
#define mp make_pair
#define pii pair<int, int>
#define vi vector<int>
#define pll pair<ll, ll>
#define fi first
#define se second
#define ull uint64_t
#define ll int64_t

//debugging snippets
#define Local freopen("input","r",stdin)
#define tr1(x)                cerr << #x << ": " << x << endl;
#define tr2(x, y)             cerr << #x << ": " << x << " | " << #y << ": " << y << endl;
#define tr3(x, y, z)          cerr << #x << ": " << x << " | " << #y << ": " << y << " | " << #z << ": " << z << endl;
#define tr4(a, b, c, d)       cerr << #a << ": " << a << " | " << #b << ": " << b << " | " << #c << ": " << c << " | " << #d << ": " << d << endl;

int n;
double l, v1, v2, k;

bool solve(double time_limit) {
    //dt+dx/v2+(len-dx-dt*v1)/v1 <= time_limit
    //dt-time_limit+len/v1-dt<=dx(1/v1-1/v2)
    double bus_offset = 0;
    double dx = (l / v1 - time_limit) / (1 / v1 - 1 / v2);
    double dt = 0;
    for (int i = 0; i < n; ++i) {
        double ext = bus_offset / (v1 + v2);
        dt += ext;
        double len = l - dt * v1;
        if (dx > len) return 0;
        if (i == n - 1) break;
        double tdt = dx / v2;
        dt += tdt;
        bus_offset = dx - tdt * v1;
    }
    //unused
    return 1;
}

int main() {
    cin >> n >> l >> v1 >> v2 >> k;
    n = (n + k - 1) / k;
    double lb = 0, ub = n * (l / v1);
    while (ub - lb > 1e-6) {
        double mid = (lb + ub) / 2.0;
        if (solve(mid)) {
            ub = mid;
        } else lb = mid;
    }
    cout << setprecision(8) << fixed;
    cout << lb << '\n';
    return 0;
}


#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp> // Common file
#include <ext/pb_ds/tree_policy.hpp> // Including tree_order_statistics_node_update

using namespace std;
using namespace __gnu_pbds;

//data structure (fenwick substitute)
template <typename T>
using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;

#define pb push_back
#define eb emplace_back
#define mp make_pair
#define pii pair<int, int>
#define vi vector<int>
#define pll pair<ll, ll>
#define fi first
#define se second
#define ull uint64_t
#define ll int64_t

//debugging snippets
#define Local freopen("input","r",stdin)
#define tr1(x)                cerr << #x << ": " << x << endl;
#define tr2(x, y)             cerr << #x << ": " << x << " | " << #y << ": " << y << endl;
#define tr3(x, y, z)          cerr << #x << ": " << x << " | " << #y << ": " << y << " | " << #z << ": " << z << endl;
#define tr4(a, b, c, d)       cerr << #a << ": " << a << " | " << #b << ": " << b << " | " << #c << ": " << c << " | " << #d << ": " << d << endl;

int n;
double l, v1, v2, k;

bool solve(double dt, double bus_offset, double time_limit) {
    //dt+dx/v2+(len-dx-dt*v1)/v1 <= time_limit
    //dt-time_limit+len/v1-dt<=dx(1/v1-1/v2)
    double dx = (l / v1 - time_limit) / (1 / v1 - 1 / v2);
    int which = n - 1;
    while (which--) {
        double ext = bus_offset / (v1 + v2);
        dt += ext;
        double len = l - dt * v1;
        if (dx > len) return 0;
        if (which == 0) return dt + len / v2 <= time_limit;
        double tdt = dx / v2;
        dt += tdt;
        bus_offset = dx - tdt * v1;
    }
    //unused
    return 1;
}

int main() {
    cin >> n >> l >> v1 >> v2 >> k;
    n = (n + k - 1) / k;
    double ans;
    if (n == 1) ans = l / v2;
    else {
        double lb = 0, ub = l;
        while (ub - lb > 1e-6) {
            double dx = (lb + ub) / 2.0;
            double dt = dx / v2;
            double tim = dt + (l - dx) / v1;
            if (solve(dt, dx - dt * v1, tim)) {
                lb = dx;
            } else ub = dx;
        }
        ans = lb / v2 + (l - lb) / v1;
    }
    cout << setprecision(8) << fixed;
    cout << ans << '\n';
    return 0;
}


   /**
▂▃▅▇█▓▒░۩۞۩ ۩۞۩░▒▓█▇▅▃▂
Make it happen now, not tomorrow.
Tomorrow is a  loser's excuse.
▂▃▅▇█▓▒░۩۞۩ ۩۞۩░▒▓█▇▅▃▂
**/
#ifndef _GLIbCXX_NO_ASSERT
#include <cassert>
#endif
#include <cctype>
#include <cerrno>
#include <cfloat>
#include <ciso646>
#include <climits>
#include <clocale>
#include <cmath>
#include <csetjmp>
#include <csignal>
#include <cstdarg>
#include <cstddef>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>

#if __cplu >= 201103L
#include <ccomplex>
#include <cfenv>
#include <cinttypes>
#include <cstdalign>
#include <cstdbool>
#include <cstdint>
#include <ctgmath>
#include <cwchar>
#include <cwctype>
#include <cstring>
#endif

// C++
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include<random>
#include <chrono>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>

#if __cplu >= 201103L
#include <array>
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <forward_list>
#include <future>
#include <initializer_list>
#include <mutex>
#include <random>
#include <ratio>
#include <regex>
#include <scoped_allocator>
#include <system_error>
#include <thread>
#include <tuple>
#include <typeindex>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#include <time.h>
#endif
#define __ ios_base::sync_with_stdio(false);cin.tie(NULL);
using namespace std;
// #define INF 0x7f7f7f7f
#define ull unsigned long long int
#define pii pair<int,int>
#define ll long long int
#define ld long double
#define MSET(x,y) memset(x,y,sizeof(x))
// #define l long
#define se second
#define AlphaSize 26
#define fi first
#define NIL 0
#define UNVISITED -1
#define EXPOLORED 0
#define mk make_pair
#define pb push_back
#define sc(n) scanf("%d",&n)
#define NIL 0
#define db double
#define pii pair<int,int>
#define eps 1e-8
#define inrange(x,y,n,m) ((x>=0 && y>=0 && x<n && y<m))
#define all(x) x.begin(),x.end()
#define me(u,v,w) make_pair(w,make_pair(u,v))
#define rep(i,a,n) for (int i=a;i<n;i++)
#define per(i,a,n) for (int i=n-1;i>=a;i--)
#define foreach(e, x) for(__typeof(x.begin()) e = x.begin(); e != x.end(); ++ e)
// #define add(a,b) (a + b >= MOD ? a+b-MOD:a+b)
#define hs(c1,c2) (256*min(c1,c2) + max(c1,c2))
#define REP(i,n) for((i)=0;(i)<(int)(n);(i)++)
typedef struct{ int sum,suf,pre,max;} Node;
int toint(const string &s) { stringstream ss; ss << s; int x; ss >> x; return x; }
const int MAXN = 2e5+100;
const int UP = 31;
// const ll inf = 1e18;
// const int mod = 1e9+7;
const ll highest = 1e18;
// const int inf = 1e9+10;
// const dou    ble pi = 3.141592653589793238462643383;
const double pi = acos(-1);
const double Phi =  1.618033988749894;
const int logn = 20;
const double root5 = 2.236067977;
const int mod = 1e9+7;
const int ini = -1e9;
/**
▂▃▅▇█▓▒░۩۞۩ ۩۞۩░▒▓█▇▅▃▂
Make it happen now, not tomorrow.
Tomorrow is a loser's excuse.
▂▃▅▇█▓▒░۩۞۩ ۩۞۩░▒▓█▇▅▃▂
**/
ll totalPupils, busSpace, numGroups;
ll walkingSpeed, busSpeed, totalDist;
int main(){
    double low, mid, high, timePassed, x, y;
    ll i;
    cin>>totalPupils>>totalDist>>walkingSpeed>>busSpeed>>busSpace;
    //We group the pupils in groups of busSpace:
    numGroups = totalPupils/busSpace;
    //Remember to add a group for those pupils left over if we can't do this exactly:
    if (totalPupils%busSpace)numGroups++;
    //The time takes at least 0 seconds and at most the number of seconds needed to complete the distance if everyone just walks:
    low = 0, high = ((double)totalDist)/((double)walkingSpeed);
    while((high-low)>=1e-8){
        mid = (low + high)/2.;
        //We keep track of the timePassed during our adventure so that if it goes over mid, we can stop our test:
        timePassed = 0;
        //Loop through each group:
        for(int i=0;i<numGroups;++i){
            /*
            Now, the current group has not gotten on the bus yet, so it has gone walkingSpeed*timePassed distance.
            We want it to go totalDist-walkingSpeed*timePassed more distance in order to complete the journey.
            If it goes on the bus for x seconds, it goes busSpeed*x distance and has mid-timePassed-x seconds left.
            In those last seconds, it can walk the rest, so it goes walkingSpeed*(mid-timePassed-x) distance.
            As we said in the second sentence, the total distance must be totalDist-walkingSpeed*timePassed in order to complete the journey, so we have the following equation:
            busSpeed*x+walkingSpeed*(mid-timePassed-x)=totalDist-walkingSpeed*timePassed
            Solve this equation for x to get:
            x=(totalDist-walkingSpeed*mid)/(busSpeed-walkingSpeed)
            This is how much time this group spends on the bus, so we add that to timePassed:
            */
            x = (((double)totalDist) - walkingSpeed*mid)/((double)(busSpeed-walkingSpeed));
            timePassed += x;
            if(i+1<numGroups){
                /*
                Now, before we added x to timePassed, both this group, the bus, and the next group were all at the same position, so let's start there.
                After x seconds, the bus is now at busSpeed*x while the next group is at walkingSpeed*x.
                Now, after another y seconds, the next group will have gone forward walkingSpeed*y more distance.
                After another y seconds, now that the bus is going backwards, the bus will have gone -busSpeed*y more distance.
                Thus, if they meet at y seconds, we get the following equation:
                walkingSpeed*x+walkingSpeed*y=busSpeed*x-busSpeed*y

                Solve this equation for y to get:
                y=x*(busSpeed-walkingSpeed)/(busSpeed+walkingSpeed)

                This is how much time the bus spends backing up, so we add that to timePassed.
                */
                y = x*((double)(busSpeed-walkingSpeed))/((double)(busSpeed+walkingSpeed));
                timePassed += y;
            }
        }
        //If we used more time than we tested for, then we can't complete the task in this much time, meaning this time is too low and we should test higher, so we highten the low bar in our binary search:
        if (timePassed > mid) low = mid;
        //Otherwise, in the case that we got through all of the groups and still have some time left, then this time is too high and we should test lower, so we lower the high bar in our binary search:
        else high = mid;
    }
    printf("%.10lf\n", low);
    return 0;
}
// struct bigint {
//     vector<int> z;
//     int sign;

//     bigint() :
//         sign(1) {
//     }

//     bigint(long v) {
//         *this = v;
//     }

//     bigint(const string &s) {
//         read(s);
//     }

//     void operator=(const bigint &v) {
//         sign = v.sign;
//         z = v.z;tor=(long long v) {
//         sign = 1;
//         if (v < return 0;0)
//             sign = -1, v = -v;
//         z.clear();
//         for (; v > 0; v = v / base)
//             z.push_back(v % base);
//     }

//     bigint operator+(const bigint &v) const {
//         if (sign == v.sign) {
//             bigint res = v;

//             for (int i = 0, carry = 0; i < (int) max(z.size(), v.z.size()) || carry; ++i) {
//                 if (i == (int) res.z.size())
//                     res.z.push_back(0);
//                 res.z[i] += carry + (i < (int) z.size() ? z[i] : 0);
//                 carry = res.z[i] >= base;
//                 if (carry)
//                     res.z[i] -= base;
//             }
//             return res;
//         }
//         return *this - (-v);
//     }

//     bigint operator-(const bigint &v) const {
//         if (sign == v.sign) {
//             if (abs() >= v.abs()) {
//                 bigint res = *this;
//                 for (int i = 0, carry = 0; i < (int) v.z.size() || carry; ++i) {
//                     res.z[i] -= carry + (i < (int) v.z.size() ? v.z[i] : 0);
//                     carry = res.z[i] < 0;
//                     if (carry)
//                         res.z[i] += base;
//                 }
//                 res.trim();
//                 return res;
//             }
//             return -(v - *this);
//         }
//         return *this + (-v);
//     }

//     void operator*=(int v) {
//         if (v < 0)
//             sign = -sign, v = -v;
//         for (int i = 0, carry = 0; i < (int) z.size() || carry; ++i) {
//             if (i == (int) z.size())
//                 z.push_back(0);
//             long long cur = z[i] * (long long) v + carry;
//             carry = (int) (cur / base);
//             z[i] = (int) (cur % base);
//             //asm("divl %%ecx" : "=a"(carry), "=d"(a[i]) : "A"(cur), "c"(base));
//         }
//         trim();
//     }

//     bigint operator*(int v) const {
//         bigint res = *this;
//         res *= v;
//         return res;
//     }

//     friend pair<bigint, bigint> divmod(const bigint &a1, const bigint &b1) {
//         int norm = base / (b1.z.back() + 1);
//         bigint a = a1.abs() * norm;
//         bigint b = b1.abs() * norm;
//         bigint q, r;
//         q.z.resize(a.z.size());

//         for (int i = a.z.size() - 1; i >= 0; i--) {
//             r *= base;
//             r += a.z[i];
//             int s1 = b.z.size() < r.z.size() ? r.z[b.z.size()] : 0;
//             int s2 = b.z.size() - 1 < r.z.size() ? r.z[b.z.size() - 1] : 0;
//             int d = ((long long) s1 * base + s2) / b.z.back();
//             r -= b * d;
//             while (r < 0)
//                 r += b, --d;
//             q.z[i] = d;
//         }

//         q.sign = a1.sign * b1.sign;
//         r.sign = a1.sign;
//         q.trim();
//         r.trim();
//         return make_pair(q, r / norm);
//     }

//     friend bigint sqrt(const bigint &a1) {
//         bigint a = a1;
//         while (a.z.empty() || a.z.size() % 2 == 1)
//             a.z.push_back(0);

//         int n = a.z.size();

//         int firstDigit = (int) sqrt((double) a.z[n - 1] * base + a.z[n - 2]);
//         int norm = base / (firstDigit + 1);
//         a *= norm;
//         a *= norm;
//         while (a.z.empty() || a.z.size() % 2 == 1)
//             a.z.push_back(0);

//         bigint r = (long long) a.z[n - 1] * base + a.z[n - 2];
//         firstDigit = (int) sqrt((double) a.z[n - 1] * base + a.z[n - 2]);
//         int q = firstDigit;
//         bigint res;

//         for(int j = n / 2 - 1; j >= 0; j--) {
//             for(; ; --q) {
//                 bigint r1 = (r - (res * 2 * base + q) * q) * base * base + (j > 0 ? (long long) a.z[2 * j - 1] * base + a.z[2 * j - 2] : 0);
//                 if (r1 >= 0) {
//                     r = r1;
//                     break;
//                 }
//             }
//             res *= base;
//             res += q;

//             if (j > 0) {
//                 int d1 = res.z.size() + 2 < r.z.size() ? r.z[res.z.size() + 2] : 0;
//                 int d2 = res.z.size() + 1 < r.z.size() ? r.z[res.z.size() + 1] : 0;
//                 int d3 = res.z.size() < r.z.size() ? r.z[res.z.size()] : 0;
//                 q = ((long long) d1 * base * base + (long long) d2 * base + d3) / (firstDigit * 2);
//             }
//         }

//         res.trim();
//         return res / norm;
//     }

//     bigint operator/(const bigint &v) const {
//         return divmod(*this, v).first;
//     }

//     bigint operator%(const bigint &v) const {
//         return divmod(*this, v).second;
//     }

//     void operator/=(int v) {
//         if (v < 0)
//             sign = -sign, v = -v;
//         for (int i = (int) z.size() - 1, rem = 0; i >= 0; --i) {
//             long long cur = z[i] + rem * (long long) base;
//             z[i] = (int) (cur / v);
//             rem = (int) (cur % v);
//         }
//         trim();
//     }

//     bigint operator/(int v) const {
//         bigint res = *this;
//         res /= v;
//         return res;
//     }

//     int operator%(int v) const {
//         if (v < 0)
//             v = -v;
//         int m = 0;
//         for (int i = z.size() - 1; i >= 0; --i)
//             m = (z[i] + m * (long long) base) % v;
//         return m * sign;
//     }

//     void operator+=(const bigint &v) {
//         *this = *this + v;
//     }
//     void operator-=(const bigint &v) {
//         *this = *this - v;
//     }
//     void operator*=(const bigint &v) {
//         *this = *this * v;
//     }
//     void operator/=(const bigint &v) {
//         *this = *this / v;
//     }

//     bool operator<(const bigint &v) const {
//         if (sign != v.sign)
//             return sign < v.sign;
//         if (z.size() != v.z.size())
//             return z.size() * sign < v.z.size() * v.sign;
//         for (int i = z.size() - 1; i >= 0; i--)
//             if (z[i] != v.z[i])
//                 return z[i] * sign < v.z[i] * sign;
//         return false;
//     }

//     bool operator>(const bigint &v) const {
//         return v < *this;
//     }
//     bool operator<=(const bigint &v) const {
//         return !(v < *this);
//     }
//     bool operator>=(const bigint &v) const {
//         return !(*this < v);
//     }
//     bool operator==(const bigint &v) const {
//         return !(*this < v) && !(v < *this);
//     }
//     bool operator!=(const bigint &v) const {
//         return *this < v || v < *this;
//     }

//     void trim() {
//         while (!z.empty() && z.back() == 0)
//             z.pop_back();
//         if (z.empty())
//             sign = 1;
//     }

//     bool isZero() const {
//         return z.empty() || (z.size() == 1 && !z[0]);
//     }

//     bigint operator-() const {
//         bigint res = *this;
//         res.sign = -sign;
//         return res;
//     }

//     bigint abs() const {
//         bigint res = *this;
//         res.sign *= res.sign;
//         return res;
//     }

//     long long longValue() const {
//         long long res = 0;
//         for (int i = z.size() - 1; i >= 0; i--)
//             res = res * base + z[i];
//         return res * sign;
//     }

//     friend bigint gcd(const bigint &a, const bigint &b) {
//         return b.isZero() ? a : gcd(b, a % b);
//     }
//     friend bigint lcm(const bigint &a, const bigint &b) {
//         return a / gcd(a, b) * b;
//     }

//     void read(const string &s) {
//         sign = 1;
//         z.clear();
//         int pos = 0;
//         while (pos < (int) s.size() && (s[pos] == '-' || s[pos] == '+')) {
//             if (s[pos] == '-')
//                 sign = -sign;
//             ++pos;
//         }
//         for (int i = s.size() - 1; i >= pos; i -= base_digits) {
//             int x = 0;
//             for (int j = max(pos, i - base_digits + 1); j <= i; j++)
//                 x = x * 10 + s[j] - '0';
//             z.push_back(x);
//         }
//         trim();
//     }

//     friend istream& operator>>(istream &stream, bigint &v) {
//         string s;
//         stream >> s;
//         v.read(s);
//         return stream;
//     }

//     friend ostream& operator<<(ostream &stream, const bigint &v) {
//         if (v.sign == -1)
//             stream << '-';
//         stream << (v.z.empty() ? 0 : v.z.back());
//         for (int i = (int) v.z.size() - 2; i >= 0; --i)
//             stream << setw(base_digits) << setfill('0') << v.z[i];
//         return stream;
//     }

//     static vector<int> convert_base(const vector<int> &a, int old_digits, int new_digits) {
//         vector<long long> p(max(old_digits, new_digits) + 1);
//         p[0] = 1;
//         for (int i = 1; i < (int) p.size(); i++)
//             p[i] = p[i - 1] * 10;
//         vector<int> res;
//         long long cur = 0;
//         int cur_digits = 0;
//         for (int i = 0; i < (int) a.size(); i++) {
//             cur += a[i] * p[cur_digits];
//             cur_digits += old_digits;
//             while (cur_digits >= new_digits) {
//                 res.push_back(int(cur % p[new_digits]));
//                 cur /= p[new_digits];
//                 cur_digits -= new_digits;
//             }
//         }
//         res.push_back((int) cur);
//         while (!res.empty() && res.back() == 0)
//             res.pop_back();
//         return res;
//     }

//     typedef vector<long long> vll;

//     static vll karatsubaMultiply(const vll &a, const vll &b) {
//         int n = a.size();
//         vll res(n + n);
//         if (n <= 32) {
//             for (int i = 0; i < n; i++)
//                 for (int j = 0; j < n; j++)
//                     res[i + j] += a[i] * b[j];
//             return res;
//         }

//         int k = n >> 1;
//         vll a1(a.begin(), a.begin() + k);
//         vll a2(a.begin() + k, a.end());
//         vll b1(b.begin(), b.begin() + k);
//         vll b2(b.begin() + k, b.end());

//         vll a1b1 = karatsubaMultiply(a1, b1);
//         vll a2b2 = karatsubaMultiply(a2, b2);

//         for (int i = 0; i < k; i++)
//             a2[i] += a1[i];
//         for (int i = 0; i < k; i++)
//             b2[i] += b1[i];

//         vll r = karatsubaMultiply(a2, b2);
//         for (int i = 0; i < (int) a1b1.size(); i++)
//             r[i] -= a1b1[i];
//         for (int i = 0; i < (int) a2b2.size(); i++)
//             r[i] -= a2b2[i];

//         for (int i = 0; i < (int) r.size(); i++)
//             res[i + k] += r[i];
//         for (int i = 0; i < (int) a1b1.size(); i++)
//             res[i] += a1b1[i];
//         for (int i = 0; i < (int) a2b2.size(); i++)
//             res[i + n] += a2b2[i];
//         return res;
//     }

//     bigint operator*(const bigint &v) const {
//         vector<int> a6 = convert_base(this->z, base_digits, 6);
//         vector<int> b6 = convert_base(v.z, base_digits, 6);
//         vll a(a6.begin(), a6.end());
//         vll b(b6.begin(), b6.end());
//         while (a.size() < b.size())
//             a.push_back(0);
//         while (b.size() < a.size())
//             b.push_back(0);
//         while (a.size() & (a.size() - 1))
//             a.push_back(0), b.push_back(0);
//         vll c = karatsubaMultiply(a, b);
//         bigint res;
//         res.sign = sign * v.sign;
//         for (int i = 0, carry = 0; i < (int) c.size(); i++) {
//             long long cur = c[i] + carry;
//             res.z.push_back((int) (cur % 1000000));
//             carry = (int) (cur / 1000000);
//         }
//         res.z = convert_base(res.z, 6, base_digits);
//         res.trim();
//         return res;
//     }
// };


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

long long n, k;
double dist, v1, v2, group;

int main()
{
    #define ll long long
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    std::ios::sync_with_stdio(false);

    cin >> n >> dist >> v1 >> v2 >> k;

    if (n % k == 0)
    {
        group = n/k;
    }
    else
    {
        group = n/k + 1;
    }

    double L = dist/v2, R = dist/v1, M = 0;
    while (R - L > 0.000001)
    {
        M = (R + L)/2;
        double t1 = (dist - M * v1)/(v2 - v1);
        double t2 = (dist - M * v1)/(v2 + v1);

        if (M >= (t1 + t2) * group - t2)
        {
            R = M;
        }
        else
        {
            L = M;
        }
    }

    cout << fixed << setprecision(12) << L;

    return 0;
}


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

long long n, k;
double dist, v1, v2, group;

bool check (double T)
{
    double t1 = (dist - T * v1)/(v2 - v1);
    double t2 = (dist - T * v1)/(v2 + v1);

    if (T >= (t1 + t2) * group - t2)
    {
        return 1;
    }
    else
    {
        return 0;
    }

}

int main()
{
    #define ll long long
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    std::ios::sync_with_stdio(false);

    cin >> n >> dist >> v1 >> v2 >> k;

    if (n % k == 0)
    {
        group = n/k;
    }
    else
    {
        group = n/k + 1;
    }

    double L = dist/v2, R = dist/v1, M = 0;
    while (R - L > 0.00000001)
    {
        M = (R + L)/2;
        if (check(M))
        {
            R = M;
        }
        else
        {
            L = M;
        }
    }

    cout << fixed << setprecision(12) << L;

    return 0;
}


#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int maxn = 1e5 + 10;
const double eps = 1e-6;
double l, v1, v2;
int n, k;
void work()
{
	scanf("%d%lf%lf%lf%d", &n, &l, &v1, &v2, &k);
	double num = n / k;
	if(n % k > 0) num++;
	double p = (num - 1) * v1 + (num - 1) * (v2 - v1) * v1 / (v1 + v2) + v2;
	double t2 = l / p;
	double t1 = (l - v2 * t2) / v1;
//	printf("t1:%f t2:%f g:%f\n", t1, t2, t2 * v2);
	printf("%.10f\n", t1 + t2);
}
int main()
{
	work();
	return 0;
}


#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int maxn = 1e5 + 10;
const double eps = 1e-6;
double l, v1, v2;
int n, k;
void work()
{
	scanf("%d%lf%lf%lf%d", &n, &l, &v1, &v2, &k);
	double num = n / k;
	if(n % k > 0) num++;
	double p = (num - 1) * v1 + (num - 1) * (v2 - v1) / (v1 + v2) + v2;
	double t2 = l / p;
	double t1 = (l - v2 * t2) / v1;
	printf("%.10f\n", t1 + t2);
}
int main()
{
	work();
	return 0;
}


#include <bits/stdc++.h>

using namespace std;

const int OO = (int) 1e9;
const double eps = 1e-15;

#define db(x) 			cout<<"> "<<(#x)<<" = "<<(x)<<'\n'
#define db2(x,y) 		cout<<"> "<<(#x)<<" = "<<(x)<<", "<<(#y)<<" = "<<(y)<<'\n'
#define db3(x,y,z) 		cout<<"> "<<(#x)<<" = "<<(x)<<", "<<(#y)<<" = "<<(y)<<", "<<(#z)<<" = "<<(z)<<'\n'
#define trav(a,x) 		for(auto&a:x)
#define lp(i,n) 		for(int i=0;i<int(n);++i)
#define lpi(i,j,n) 		for(int i=j;i<int(n);++i)
#define lpd(i,j,n) 		for(int i=j;i>=int(n);--i)
#define ndl 			cout<<'\n'
#define all(v) 			v.begin(),v.end()
#define rall(v) 		v.rbegin(),v.rend()
#define present(a,x) 	(a.find(x)!=a.end())
#define cpresent(a,x) 	(find(all(a),x)!=a.end())
#define sz(v) 			int(v.size())
#define clr(v, d) 		memset(v,d,sizeof(v))
#define pb 				push_back
#define mp 				make_pair
#define fs 				first
#define sc 				second

typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<pii> vii;
typedef vector<vector<int> > vvi;
typedef map<int, int> mii;
typedef set<int> si;

int n,l,v1,v2,k;

bool good(double mid){
	double left=mid,y=0;
	int grps=(n+k-1)/k;
	while(true){
		if (left<-eps)
			return false;
		if ((l-y)/v1<left+eps)
			return true;
		if ((l-y)/v2>left-eps)
			return false;
		--grps;
		if (!grps)
			return true;
		double t1=(l-y-v1*left)/(v2-v1),d1=v2*t1,a=y+v1*t1,b=y+d1;
		double d=b-a;
		left-=t1+d/(v1+v2),y=a+v1*d/(v1+v2);/*
		db3(t1,d1,left);
		db3(a,b,y);
		ndl;*/
	}
}

double bs(){
	double lo=0,hi=1e12,mid;
	lp(i,1000){
		mid=(lo+hi)/2;/*
		db(mid);*/
		if (good(mid))
			hi=mid;
		else
			lo=mid;
	}
	return mid;
}

int main() {
	ios::sync_with_stdio(false);
	cout.precision(15);
	cout<<fixed;
	cin>>n>>l>>v1>>v2>>k;
	cout<<bs();
	return 0;
}


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

signed main(){
	ios::sync_with_stdio(false),cin.tie(0),cout.tie(0);
	int n,l,k;
	double v1,v2;

	cin>>n>>l>>v1>>v2>>k;
	int cint = (n+k-1)/k;
	double c = cint;

	double x = (v2*v1+v2*v2)*l/(2*v1*(c-1)+v1*v2*(c-1)+v1*v2+v2*v2);
	double t = x/v2 + (l-x)/v1;
	// cout<<x<<endl;
	// cout<<c<<endl;
	cout<<fixed<<setprecision(9)<<t<<endl;

	return 0;
}


/*
数学玄学题
车一次移动的最佳距离为a，此时能保证最后的人和载人的车同时冲线
人数 n
总距离 l
人的速度 v1
车的速度 v2
一组人数 k
组数g=[n/k]
两个等式
	对于一人一车同时前进，车走了距离a后回来接人，这个总时间为t1，人车距离和为2*a
			2*a=v1*t1+v2*t1
		即
			t1=2*a/(v1+v2)

	由于最后大家一起冲线，人和车的总时间是相同的
	车送g组人，其中
		返回来接的g-1组 t1*(g-1)
		一组不需要返回 a/v2
	人的时间
		乘车 a/v2
		走路 (l-a)/v1
	即
		a/v2+t1*(g-1)=a/v2+(l-a)/v1
	化简
		t1=(l-a)/(v1*(g-1))
	带入上一个等式
		a=( l*(v1+v2) ) / (2*v1*g+v2-v1)

	总时间 t0=a/v2+(l-a)/v1
			 =l/v1+a*(v1-v2)/v1*v2
*/
#include<bits/stdc++.h>
//#define endl "\n"
using namespace std;
int main()
{
	//ios::sync_with_stdio(false);
	//cin.tie(0);
	int n,l,v1,v2,k,g;
	cin>>n>>l>>v1>>v2>>k;
	if (n%k==0) g=n/k;
	else g=n/k+1;
	double a=( 1.0*l*(v1+v2) ) /(1.0*(1.0*2*v1*g+v2*1.0-v1*1.0));
	double ans=(l*1.0)/v1+( 1.0*a*(v1-v2) ) /(1.0*v1*v2);
	printf("%.11lf",ans);
	return 0;
}


#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<vector>
#include<map>

using namespace std;
const int maxn=1e4+10, INF=1e9+7;
const double eps=1e-6;
int main()
{
    int n, k;
    double l, v1, v2;
    scanf("%d%lf%lf%lf%d", &n, &l, &v1, &v2, &k);
    double x = n / k + (n%k > 0);
	double y = (x - 1) * (v2 - v1) / (v1 + v2);
	double t2 = l / v2 / (x - y);
	double t1 = (l - t2 * v2) / v1;
	printf("%.10f\n", t1 + t2);
}


#include <cstdio>
#include <cmath>
#include <algorithm>
#include <cstring>
#include <cstdlib>
#include <queue>
#include <set>
#include <stack>
#include <map>
#include <vector>
#include <iostream>
using namespace std;
#define ll long long
ll n,l,v1,v2,k;
int main(){
    cin >> n >> l >> v1 >> v2 >> k;

    double L=0,R=l*1.0/v2;
    int dd = n/k;
    double d = dd;
    if(k*dd==n) d = dd-1;
    while(abs(L-R)>0.0000001){
       // cout << L << " " << R <<endl;
        double m = (L+R)/2;
        if(d*((v2*m-v1*m)/(v1+v2)+m)<=(l-v2*m)/v1){
            L = m;
        }
        else R = m;
    }
    printf("%.10f",L+(l-v2*L)/v1);
    return 0;
}


#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int main()
{
    ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
    int n,k;
    double v1,v2,l;
    cin>>n>>l>>v1>>v2>>k;
    int cint =  (n+k-1)/k;
    double c = cint;

    double x = (v2*(v1+v2)*l/(v1*v2*(c-1)+v1*v2+v2*v2+v2*v1*(c-1));
    double t=x/v2 + (l-x)/v1;
    cout<<fixed<<setprecision(9)<<t<<endl;
}


// qdd on Jul 12, 2018

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

int main()
{
    int n, l, v1, v2, k;
    cin >> n >> l >> v1 >> v2 >> k;
    double x = (n + k - 1) / k;
	double y = (x - 1) * (v2 - v1) / (v1 + v2);
	double t2 = l / v2 / (x - y);
	double t1 = (l - t2 * v2) / v1;
    printf("%.8f\n", t1 + t2);
    return 0;
}


// qdd on Jul 12, 2018

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

int main()
{
    int n, l, v1, v2, k;
    cin >> n >> l >> v1 >> v2 >> k;
    double x = (n + k - 1) / k;
	double y = (x - 1) * (v2 - v1) / (v1 + v2);
	double t2 = 1.0 * l / v2 / (x - y);
	double t1 = (l - t2 * v2) / v1;
    printf("%.8f\n", t1 + t2);
    return 0;
}


#include <iostream>
#include <stdio.h>
using namespace std;
int main()
{
    int n,k;
    double l,v1,v2;
    cin >> n >> l >> v1 >> v2 >> k;
    int g = n/k + (n%k == 0 ? 0 : 1);
    double dis = (v1+v2)*l/(2*v1*(g-1)+v1+v2);
    double ans = dis/v2 + (l-dis)/v1;
    printf("%.10lf\n",ans);
}


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

signed main(){
	ios::sync_with_stdio(false),cin.tie(0),cout.tie(0);
	int n,l,k;
	double v1,v2;

	cin>>n>>l>>v1>>v2>>k;
	if(v1 < v2){
		int cint = (n+k-1)/k;
		double c = cint;

		double x = (v2*v1+v2*v2)*l/(2*v1*(c-1)+v1*v2*(c-1)+v1*v2+v2*v2);
		double t = x/v2 + (l-x)/v1;
		// cout<<x<<endl;
		// cout<<c<<endl;
		cout<<fixed<<setprecision(9)<<t<<endl;
	}
	else{
		cout<<fixed<<setprecision(9)<<((double)l)/v1<<endl;
	}
	return 0;
}


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

int main(void){

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

    double grp = (int)((n+k-1)/k);

    double a = ( l*(v1+v2) ) / (2*v1*grp + v2 - v1);
    double ans = a/v2 + (l-a)/v1;

    printf("%.10f",ans);

    return 0;
}


#include<bits/stdc++.h>
#define maxn 100100
using namespace std;
typedef long long ll;
int n,k;
ll v1,v2,l;
double t;
int main()
{
    scanf("%d%I64d%I64d%I64d%d",&n,&l,&v1,&v2,&k);
    if(n==k) t=l*1.0/v2;
    else
    {
        int num=(n+k-1)/k;
        num--;
        double t1,t2;
        t2=l*(v1+v2)*1.0/(2*num*v1*v2+v1*v2+v2*v2);
        t1=t2*num*2*v2/(v2+v1);
        t=t1+t2;
    }
    printf("%.7f",t);
}


#include<bits/stdc++.h>
#define maxn 100100
using namespace std;
typedef long long ll;
int n,k;
ll v1,v2,l;
double t;
int main()
{
    scanf("%d%I64d%I64d%I64d%d",&n,&l,&v1,&v2,&k);
    if(n==k) t=l*1.0/v2;
    else
    {
        int num=(n+k-1)/k;
        num--;
        double t1,t2;
        t2=l*(v1+v2)*1.0/((double)2*num*v1*v2+(double)v1*v2+(double)v2*v2);
        t1=t2*num*2*v2/(v2+v1);
        t=t1+t2;
    }
    printf("%.10f",t);
}


#include "bits/stdc++.h"
using namespace std;
int n,l,v1,v2,k,trips;
double lo,hi=1e10,mid,ans,pos,dist,x;

bool f(double t)
{
	pos=0;
	for(int i=0;i<trips and pos<=l and t>=0;i++)
	{
		dist=l-pos;
		if(i!=trips-1)
		{
			x=(t*v1*v2-v2*dist)/(v1-v2);
			t-=(x/v2);
			t-=x*(v2-v1)/(v2*(v1+v2));
			pos+=(x*v1/v2)+((x*(v2-v1)/v2)*v1/(v1+v2));
		}
		else
		{
			x=l-pos;
			t-=x/v2;
			pos=l;
		}
	}
	return pos<=l and t>=0;
}

int main()
{
	scanf("%d%d%d%d%d",&n,&l,&v1,&v2,&k);

	trips=n/k+(n%k!=0);
	for(int it=0;it<1e3;it++)
	{
		mid=(lo+hi)/2;

		if(f(mid)) ans=hi=mid;
		else lo=mid;
	}

	printf("%.10f",ans);
}


#include "bits/stdc++.h"
using namespace std;
int n,l,v1,v2,k,trips;
double lo,hi=1e10,mid,ans,pos,dist,x;

bool f(double t)
{
	pos=0;
	for(int i=0;i<trips and pos<=l and t>=0;i++)
	{
		dist=l-pos;
		if(i!=trips-1)
		{
			x=(t*v1*v2-v2*dist)/(v1-v2);
			t-=(x/v2);
			t-=x*(v2-v1)/(1LL*v2*(v1+v2));
			pos+=(x*v1/v2)+((x*(v2-v1)/v2)*v1/(v1+v2));
		}
		else
		{
			x=l-pos;
			t-=x/v2;
			pos=l;
		}
	}
	return pos<=l and t>=0;
}

int main()
{
	scanf("%d%d%d%d%d",&n,&l,&v1,&v2,&k);

	trips=n/k+(n%k!=0);
	for(int it=0;it<50;it++)
	{
		mid=(lo+hi)/2;

		if(f(mid)) ans=hi=mid;
		else lo=mid;
	}

	printf("%.10f",ans);
}


#include "bits/stdc++.h"
using namespace std;
int n,l,v1,v2,k,trips;
double lo,hi=1e10,mid,ans,pos,dist,x;

bool f(double t)
{
	pos=0;
	for(int i=0;i<trips and pos<=l and t>=0;i++)
	{
		dist=l-pos;
		if(i!=trips-1)
		{
			x=(t*v1*v2-v2*dist)/(v1-v2);
			t-=(x/v2);
			t-=x*(v2-v1)/(1LL*v2*(v1+v2));
			pos+=(x*v1/v2)+((x*(v2-v1)/v2)*v1/(v1+v2));
		}
		else
		{
			x=l-pos;
			t-=x/v2;
			pos=l;
		}
	}
	return pos<=l and t>=0;
}

int main()
{
	scanf("%d%d%d%d%d",&n,&l,&v1,&v2,&k);

	trips=n/k+(n%k!=0);
	for(int it=0;it<1e3;it++)
	{
		mid=(lo+hi)/2;

		if(f(mid)) ans=hi=mid;
		else lo=mid;
	}

	printf("%.10f",ans);
}


#include "bits/stdc++.h"
using namespace std;
int n,l,v1,v2,k,trips;
double lo,hi=1e10,mid,ans,pos,dist,x;

bool f(double t)
{
	pos=0;
	for(int i=0;i<trips and pos<=l and t>=0;i++)
	{
		dist=l-pos;
		if(i!=trips-1)
		{
			x=(t*v1*v2-v2*dist)/(v1-v2);
			t-=(x/v2);
			t-=x*(v2-v1)/(1LL*v2*(v1+v2));
			pos+=(x*v1/v2)+((x*(v2-v1)/v2)*v1/(v1+v2));
		}
		else
		{
			x=l-pos;
			t-=x/v2;
			pos=l;
		}
	}
	return pos<=l and t>=0;
}

int main()
{
	scanf("%d%d%d%d%d",&n,&l,&v1,&v2,&k);

	trips=n/k+(n%k!=0);
	for(int it=0;it<100;it++)
	{
		mid=(lo+hi)/2;

		if(f(mid)) ans=hi=mid;
		else lo=mid;
	}

	printf("%.10f",ans);
}


#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef string str;
typedef double db;
typedef vector<int> vi;
typedef vector<char> vc;
typedef vector<bool> vb;
typedef vector<long long> vll;
typedef pair<int, int> pii;
#define pb push_back
#define mp make_pair
#define fi first
#define se second
#define in insert
#define all(x) (x).begin(), (x).end()
#define speed ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
const int INF = 1e9 + 5;

/* ZYN ZYN ZYN ZYN ZYN ZYN ZYN ZYN */

int gcd(int x,int y){return y?gcd(y,x%y):x;}

int main(){
    speed;
    int n, l, k;
    double v1, v2;
    cin >> n >> l >> v1 >> v2 >> k;
    int cnt = (n + k - 1) / k;
    if (cnt == 1){
        cout << l / v2 << endl;
        return 0;
    }
    double x = l / (1 + 2 * v1 / (v1 + v2) * (cnt - 1));
    double t = x / v2 + (l - x) / v1;
    cout << fixed << setprecision(12) << t << endl;
    return 0;
}


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

int n, k;
double L, v1, v2;

bool check(double T)
{
	double cur_pos = 0;
	for(int i = 0; i * k < n; ++i)
	{
		double l = cur_pos,
			r = L;
		for(int j = 0; j < 70; ++j)
		{
			double mid = (l + r) / 2;
			if((mid - cur_pos) / v2 + (L - mid) / v1 <= T)
			{
				r = mid;
			} else
			{
				l = mid;
			}
		}
		T -= (l - cur_pos) / v2;
		if((i + 1) * k < n)
		{
			cur_pos += ((l - cur_pos) / v2) * v1;
			if(T >= 0 && cur_pos >= L)
			{
				return true;
			}
			double new_pos = (l - cur_pos) / (v1 + v2);
			cur_pos += new_pos * v1;
			T -= (l - cur_pos) / v2;
		}
	}
	return T >= 0;
}

int main (int argc, char *argv[])
{
	scanf("%d%lf%lf%lf%d", &n, &L, &v1, &v2, &k);
	double l = 0,
		r = 1e9;
	for(int i = 0; i < 70; ++i)
	{
		double mid = (l + r) / 2;
		if(check(mid))
		{
			r = mid;
		} else
		{
			l = mid;
		}
	}
	printf("%.15lf", l);

	return 0;
}


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

int n, k;
double L, v1, v2;

bool check(double T)
{
	double cur_pos = 0;
	for(int i = 0; i * k < n; ++i)
	{
		double l = cur_pos,
			r = L;
		for(int j = 0; j < 70; ++j)
		{
			double mid = (l + r) / 2;
			if((mid - cur_pos) / v2 + (L - mid) / v1 <= T)
			{
				r = mid;
			} else
			{
				l = mid;
			}
		}
		T -= (l - cur_pos) / v2;
		if((i + 1) * k < n)
		{
			cur_pos += ((l - cur_pos) / v2) * v1;
			if(T >= 0 && cur_pos >= L)
			{
				return true;
			}
			double new_pos = (l - cur_pos) / (v1 + v2);
			cur_pos += new_pos;
			T -= (l - cur_pos) / v2;
		}
	}
	return T >= 0;
}

int main (int argc, char *argv[])
{
	scanf("%d%lf%lf%lf%d", &n, &L, &v1, &v2, &k);
	double l = 0,
		r = 1e9;
	for(int i = 0; i < 70; ++i)
	{
		double mid = (l + r) / 2;
		if(check(mid))
		{
			r = mid;
		} else
		{
			l = mid;
		}
	}
	printf("%.15lf", l);

	return 0;
}


#include <iostream>
#include <vector>
#include <string>
#include <utility>
#include <algorithm>
#include <map>
#include <set>

using namespace std;

int main()
{
    ios::sync_with_stdio(false);

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

    int64_t numGroups = (n + k - 1) / k;

    double low = 0, high = (double)l / v1, mid;
    double time;
    while (high - low >= 5e-7) {
        mid = (low + high) / 2.;
        time = 0;

        for (int i = 0; i < numGroups; ++i) {
            double x = (l - v1 * mid) / (v2 - v1);
            time += x;

            if (i+1 < numGroups) {
                double y = x * (v2 - v1) / (v2 + v1);
                time += y;
            }
        }

        if (time > mid) {
            low = mid;
        } else {
            high = mid;
        }
    }
    //cout.precision(6);
    cout << fixed << low << endl;

    return 0;
}


#include <iostream>
#include <vector>
#include <string>
#include <utility>
#include <algorithm>
#include <map>
#include <set>

using namespace std;

int main()
{
    ios::sync_with_stdio(false);

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

    int64_t numGroups = (n + k - 1) / k;

    double low = 0, high = (double)l / v1, mid;
    double time;
    while (high - low >= 5e-9) {
        mid = (low + high) / 2.;
        time = 0;

        for (int i = 0; i < numGroups; ++i) {
            double x = (l - v1 * mid) / (v2 - v1);
            time += x;

            if (i+1 < numGroups) {
                double y = x * (v2 - v1) / (v2 + v1);
                time += y;
            }
        }

        if (time > mid) {
            low = mid;
        } else {
            high = mid;
        }
    }
    cout.precision(17);
    cout << fixed << low << endl;

    return 0;
}


#include <iostream>
#include <vector>
#include <string>
#include <utility>
#include <algorithm>
#include <map>
#include <set>

using namespace std;

int main()
{
    ios::sync_with_stdio(false);

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

    int64_t numGroups = (n + k - 1) / k;

    double low = 0, high = (double)l / v1, mid;
    double time;
    while (high - low >= 5e-7) {
        mid = (low + high) / 2.;
        time = 0;

        for (int i = 0; i < numGroups; ++i) {
            double x = (l - v1 * mid) / (v2 - v1);
            time += x;

            if (i+1 < numGroups) {
                double y = x * (v2 - v1) / (v2 + v1);
                time += y;
            }
        }

        if (time > mid) {
            low = mid;
        } else {
            high = mid;
        }
    }
    cout.precision(17);
    cout << fixed << low << endl;

    return 0;
}