#include <bits/stdc++.h>
using namespace std;
int nf, ne, ns;
double rf, re, rs;
double df, de;
int pos[15][2];
double ans;
double dp[25][25];
const int N = 10;
int cnt(int x) { return pos[x][0] + pos[x][1]; }
struct plan {
  double f, e;
};
bool operator<(plan a, plan b) { return a.f > b.f; }
double overlap(double x, double rx, double y, double ry) {
  double xl = x - rx, xr = x + rx;
  double yl = y - ry, yr = y + ry;
  if (xl < yl) swap(xl, yl), swap(xr, yr);
  if (xr <= yr) return xr - xl;
  return yr - xl;
}
void check() {
  double res = nf * rf * df + ne * re * de;
  vector<plan> vs;
  for (int i = 1; i <= N; i++) {
    double olf = 0, ole = 0;
    for (int j = 1; j <= N; j++)
      olf += cnt(j) * max(0.0, overlap(i, rf, j, rs)),
          ole += cnt(j) * max(0.0, overlap(i, re, j, rs));
    plan ol;
    ol.f = olf * df, ol.e = ole * de;
    for (int j = 0; j < 2 - cnt(i); j++) vs.push_back(ol);
  }
  sort(vs.begin(), vs.end());
  for (int i = 0; i <= nf; i++) {
    for (int j = 0; j <= ne; j++) {
      if (i == 0 and j == 0) continue;
      if (i == 0)
        dp[i][j] = dp[i][j - 1] + vs[i + j - 1].e;
      else if (j == 0)
        dp[i][j] = dp[i - 1][j] + vs[i + j - 1].f;
      else
        dp[i][j] =
            max(dp[i - 1][j] + vs[i + j - 1].f, dp[i][j - 1] + vs[i + j - 1].e);
    }
  }
  ans = max(ans, res + res + dp[nf][ne]);
}
int slag;
void dfs(int x) {
  if (ns < 0) return;
  if (x == N + 1) {
    check();
    return;
  }
  int bslag = slag;
  pos[x][1] = 1;
  ns--;
  dfs(x + 1);
  pos[x][0] = 1;
  ns--;
  slag = 1;
  dfs(x + 1);
  slag = bslag;
  pos[x][1] = 0;
  ns++;
  if (slag) dfs(x + 1);
  pos[x][0] = 0;
  ns++;
  dfs(x + 1);
}
int main() {
  cin >> nf >> ne >> ns >> rf >> re >> rs >> df >> de;
  rf = sqrt(rf * rf - 1);
  re = sqrt(re * re - 1);
  rs = sqrt(rs * rs - 1);
  dfs(1);
  printf("%.8lf", ans);
}
