#include <bits/stdc++.h>
using namespace std;
int nFire, nElectric, nSlow;
int radFire, radElectric, radSlow;
double intRadFire, intRadElectric, intRadSlow;
int damageFire, damageElectric;
const int MAXMASK = 1594323;
const int MAXN = 13;
int used[MAXN];
pair<double, double> damage[MAXN][MAXN];
double intersect(pair<double, double> a, pair<double, double> b) {
  double x = max(a.first, b.first);
  double y = min(a.second, b.second);
  return max(0.0, y - x);
}
void calcIntRads() {
  intRadFire = sqrt(radFire * radFire - 1.0);
  intRadElectric = sqrt(radElectric * radElectric - 1.0);
  intRadSlow = sqrt(radSlow * radSlow - 1.0);
}
void calcDamage() {
  for (int i = 0; i < MAXN; ++i) {
    for (int j = 0; j < MAXN; ++j) {
      pair<double, double> intervalFire =
          pair<double, double>(double(i) - intRadFire, double(i) + intRadFire);
      pair<double, double> intervalElectric = pair<double, double>(
          double(i) - intRadElectric, double(i) + intRadElectric);
      pair<double, double> intervalSlow =
          pair<double, double>(double(j) - intRadSlow, double(j) + intRadSlow);
      damage[i][j].first =
          double(damageFire) * intersect(intervalFire, intervalSlow);
      damage[i][j].second =
          double(damageElectric) * intersect(intervalElectric, intervalSlow);
    }
  }
}
vector<int> slow;
pair<double, double> score[MAXN];
vector<int> ind;
int n;
bool my_comp(const int& i, const int& j) {
  return score[i].first > score[j].first;
}
double dp[2 * MAXN][21];
double f(int next, int electric) {
  if (dp[next][electric] > -0.5) return dp[next][electric];
  if (electric == 0 && next - (nElectric - electric) >= nFire) {
    dp[next][electric] = 0.0;
    return 0.0;
  }
  double ret = 0.0;
  double tmp;
  if (electric > 0) {
    tmp = score[ind[next]].second + f(next + 1, electric - 1);
    if (tmp > ret) ret = tmp;
  }
  if (next - (nElectric - electric) < nFire) {
    tmp = score[ind[next]].first + f(next + 1, electric);
    if (tmp > ret) ret = tmp;
  }
  dp[next][electric] = ret;
  return ret;
}
int main() {
  cin >> nFire >> nElectric >> nSlow;
  cin >> radFire >> radElectric >> radSlow;
  cin >> damageFire >> damageElectric;
  double ret = 0.0;
  calcIntRads();
  calcDamage();
  slow.resize(nSlow);
  ind.resize(26 - nSlow);
  for (int mask = 0; mask < MAXMASK; ++mask) {
    int tempMask = mask;
    int nBits = 0;
    for (int i = 0; i < MAXN; ++i) {
      nBits += tempMask % 3;
      tempMask /= 3;
    }
    if (nBits != nSlow) continue;
    tempMask = mask;
    int nextSlow = 0;
    int n = 0;
    for (int i = 0; i < MAXN; ++i) {
      int temp = tempMask % 3;
      tempMask /= 3;
      used[i] = temp;
      if (temp == 0) {
        ind[n] = i;
        ++n;
        ind[n] = i;
        ++n;
      }
      if (temp == 1) {
        slow[nextSlow] = i;
        ++nextSlow;
        ind[n] = i;
        ++n;
      }
      if (temp == 2) {
        slow[nextSlow] = i;
        ++nextSlow;
        slow[nextSlow] = i;
        ++nextSlow;
      }
    }
    double tempScore = 0.0;
    tempScore += double(nFire) * 2.0 * intRadFire * double(damageFire);
    tempScore +=
        double(nElectric) * 2.0 * intRadElectric * double(damageElectric);
    for (int i = 0; i < MAXN; ++i) {
      if (used[i] < 2) {
        score[i].first = 0.0;
        score[i].second = 0.0;
        for (int j = 0; j < nSlow; ++j) {
          score[i].first += damage[i][slow[j]].first;
          score[i].second += damage[i][slow[j]].second;
        }
      }
    }
    sort(ind.begin(), ind.end(), my_comp);
    for (int i = 0; i < 2 * MAXN; ++i) {
      for (int j = 0; j <= nElectric; ++j) {
        dp[i][j] = -1.0;
      }
    }
    tempScore += f(0, nElectric);
    if (tempScore > ret) ret = tempScore;
  }
  cout.setf(ios::fixed);
  cout.precision(9);
  cout << ret << endl;
  return 0;
}
