#include <bits/stdc++.h>
template <typename T>
std::ostream& operator<<(std::ostream& out, const std::vector<T>& v) {
  if (!v.empty()) {
    std::copy(v.begin(), v.end(), std::ostream_iterator<T>(out, " "));
  }
  return out;
}
template <typename T1, typename T2>
std::ostream& operator<<(std::ostream& out, const std::pair<T1, T2>& pa) {
  out << pa.first << " " << pa.second;
  return out;
}
template <typename T>
std::istream& operator>>(std::istream& is, std::vector<T>& v) {
  v.clear();
  size_t siz;
  is >> siz;
  v.reserve(siz);
  T value;
  for (size_t i = 0; i < siz; i++) {
    is >> value;
    v.push_back(value);
  }
  return is;
}
template <typename T1, typename T2>
std::istream& operator>>(std::istream& is, std::pair<T1, T2>& pa) {
  is >> pa.first >> pa.second;
  return is;
}
using namespace std;
vector<int> freeze;
int nf, ne, ns;
int rf, re, rs;
double lf, le, ls;
int df, de;
int pos[11] = {2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2};
double dp[11][21][21] = {};
double ans = 0.0;
int len;
double fire(int pos) {
  double mine = pos - lf, maxe = pos + lf;
  double ans = 2.0 * lf * df;
  for (int x : freeze) {
    double minef = x - ls, maxef = x + ls;
    if (mine >= maxef || maxe <= minef) continue;
    double cmn = min(maxe, maxef) - max(mine, minef);
    ans += cmn * df;
  }
  return ans;
}
double electric(int pos) {
  double mine = pos - le, maxe = pos + le;
  double ans = 2.0 * le * de;
  for (int x : freeze) {
    double minef = x - ls, maxef = x + ls;
    if (mine >= maxef || maxe <= minef) continue;
    double cmn = min(maxe, maxef) - max(mine, minef);
    ans += cmn * de;
  }
  return ans;
}
double work() {
  memset(dp, 0, sizeof(dp));
  double ans = 0;
  for (int i = 1; i <= len; i++) {
    for (int j = 0; j <= nf; j++) {
      for (int k = 0; k <= ne; k++) {
        dp[i][j][k] = dp[i - 1][j][k];
        double f = fire(i), e = electric(i);
        if (pos[i]) {
          if (j != nf) dp[i][j][k] = max(dp[i][j][k], dp[i - 1][j + 1][k] + f);
          if (k != ne) dp[i][j][k] = max(dp[i][j][k], dp[i - 1][j][k + 1] + e);
        }
        if (pos[i] > 1) {
          if (j < nf - 1)
            dp[i][j][k] = max(dp[i][j][k], dp[i - 1][j + 2][k] + 2 * f);
          if (k < ne - 1)
            dp[i][j][k] = max(dp[i][j][k], dp[i - 1][j][k + 2] + 2 * e);
          if (j < nf && k < ne)
            dp[i][j][k] = max(dp[i][j][k], dp[i - 1][j + 1][k + 1] + f + e);
        }
        ans = max(ans, dp[i][j][k]);
      }
    }
  }
  return ans;
}
void dfs(int x) {
  if (ns == 0 || x > len) {
    ans = max(ans, work());
    return;
  }
  dfs(x + 1);
  if (ns <= 0) return;
  ns--;
  pos[x]--;
  freeze.push_back(x);
  dfs(x + 1);
  if (ns <= 0) {
    freeze.pop_back();
    ns++;
    pos[x]++;
    return;
  }
  ns--;
  pos[x]--;
  freeze.push_back(x);
  dfs(x + 1);
  ns += 2;
  pos[x] += 2;
  freeze.pop_back();
  freeze.pop_back();
}
int main() {
  ios::sync_with_stdio(false);
  cin.tie(NULL);
  cin >> nf >> ne >> ns;
  cin >> rf >> re >> rs;
  cin >> df >> de;
  len = (nf + ne + ns + 1) / 2;
  lf = sqrt(rf * rf - 1);
  le = sqrt(re * re - 1);
  ls = sqrt(rs * rs - 1);
  dfs(1);
  cout << fixed << setprecision(20) << ans << endl;
  return 0;
}
