#include <bits/stdc++.h>
#define rep(i,n) for(int i = 0; i < (int)(n); i++)

using namespace std;
using LL = long long;
using P = pair<int,int>;
using vv = vector<vector<int>>;
const int INF = (int)1e9;
const LL LINF = (LL)1e18;
const int query = 1000;
const int grid_size = 30;
const int grid_total = grid_size * grid_size;
const int initial_length = 4000;

string path_ex(int si, int sj, int ti, int tj){
	int di = ti - si, dj = tj - sj;
	string s;
	if(di >= 0) rep(k,di) s.push_back('D');
	else rep(k,-di) s.push_back('U');
	if(dj >= 0) rep(k,dj) s.push_back('R');
	else rep(k,-dj) s.push_back('L');
	return s;
}

vector<vector<int>> G;
int cost[grid_total][grid_total];
int update_number[grid_total][grid_total];

void length_update(int from, int to, int ave_length){
	int now_length = cost[from][to];
	int num = update_number[from][to] + 1;
	int new_length = (now_length * num + ave_length) / (num + 1);
	cost[from][to] = new_length, cost[to][from] = new_length;
	update_number[from][to]++, update_number[to][from]++;
}

string dijkstra(int st, int ed){
   int N = G.size();
   vector<int> dist(N, INF), par(N, -1);
   dist[st] = 0;
   priority_queue<P,vector<P>,greater<P>> q;
   q.push({dist[st], st});
   while(!q.empty()){
	   P p = q.top(); q.pop();
	   int d = p.first, n = p.second;
	   if(dist[n] < d) continue;
	   for(auto v : G[n]){
		   int c = cost[n][v];
		   if(dist[v] <= d + c) continue;
		   dist[v] = d + c;
		   q.push({dist[v], v});
		   par[v] = n;
	   }
   }
   string path;
   int now = ed;
   while(now != st){
	   char c;
	   if(par[now] + 1 == now) c = 'R';
	   else if(par[now] - 1 == now) c = 'L';
	   else if(par[now] + grid_size == now) c = 'D';
	   else c = 'U';
	   path.push_back(c);
	   now = par[now];
   }
   reverse(path.begin(), path.end());
   return path;
}

int main(){
	//FILE *outputfile;
	//outputfile = freopen("test.txt", "w", stdout);

	G.resize(grid_total);
	rep(i,grid_size){
		rep(j,grid_size) cost[i][j] = INF;
	}
	rep(i,grid_size){
		rep(j,grid_size-1){
			int l = i * grid_size + j, r = i * grid_size + j + 1;
			assert(l < grid_total and r < grid_total);
			G[l].emplace_back(r);
			G[r].emplace_back(l);
			cost[l][r] = initial_length, cost[r][l] = initial_length;
		}
	}
	rep(j,grid_size){
		rep(i,grid_size-1){
			int u = i * grid_size + j, d = (i + 1) * grid_size + j;
			assert(u < grid_total and d < grid_total);
			G[u].emplace_back(d);
			G[d].emplace_back(u);
			cost[u][d] = initial_length, cost[d][u] = initial_length;
		}
	}
	rep(q,query){
		int si, sj, ti, tj;
		cin >> si >> sj >> ti >> tj;
		int st = si * grid_size + sj, ed = ti * grid_size + tj;
		assert(st < grid_total and ed < grid_total);
		string path = dijkstra(st, ed);
		cout << path << endl;
		int dist_result;
		cin >> dist_result;
		int path_size = path.size();
		
		random_device rnd;
		mt19937 mt(rnd());
		uniform_real_distribution<> rand_e(0.9, 1.1);
		//uniform_int_distribution<> rand_length(1, 1000);

		int sum_result = 0;
		vector<int> path_vertices(path_size + 1);
		path_vertices[0] = st;
		rep(k,path_size){
			int now = path_vertices[k];
			if(path[k] == 'R') now++;
			else if(path[k] == 'L') now--;
			else if(path[k] == 'D') now += grid_size;
			else now -= grid_size;
			path_vertices[k+1] = now;
		}
		rep(k,path_size){
			int from = path_vertices[k], to = path_vertices[k+1];
			int ave_length = dist_result / path_size;
			length_update(from, to, ave_length);
			sum_result += cost[from][to];
		}
		/*
		int dif = dist_result - sum_result;
		rep(k,path_size){
			int pre = path_vertices[k], now = path_vertices[k+1];	
			cost[pre][now] += dif / path_size;
			cost[now][pre] += dif / path_size;
		}
		*/
	}

	return 0;
}

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

int main() {
  double a, b, c, d;
  cin >> a >> c >> b >> d;
  cout << fixed << setprecision(10);
  cout << c * (b-a) / (c+d) + a << endl;
}