Problem: Vasya plays the Power Defence. 

He must pass the last level of the game. In order to do this he must kill the Main Villain, who moves in a straight line at speed 1 meter per second from the point ( - ∞, 0) to the point ( + ∞, 0) of the game world. In the points (x, 1) and (x, - 1), where x is an integer number, Vasya can build towers of three types: fire-tower, electric-tower or freezing-tower. However, it is not allowed to build two towers at the same point. Towers of each type have a certain action radius and the value of damage per second (except freezing-tower). If at some point the Main Villain is in the range of action of k freezing towers then his speed is decreased by k + 1 times.

The allowed number of towers of each type is known. It is necessary to determine the maximum possible damage we can inflict on the Main Villain.

All distances in the problem are given in meters. The size of the Main Villain and the towers are so small, that they can be considered as points on the plane. The Main Villain is in the action radius of a tower if the distance between him and tower is less than or equal to the action radius of the tower.

Input

The first line contains three integer numbers nf, ne and ns — the maximum number of fire-towers, electric-towers and freezing-towers that can be built (0 ≤ nf, ne, ns ≤ 20, 1 ≤ nf + ne + ns ≤ 20). The numbers are separated with single spaces.

The second line contains three integer numbers rf, re and rs (1 ≤ rf, re, rs ≤ 1000) — the action radii of fire-towers, electric-towers and freezing-towers. The numbers are separated with single spaces.

The third line contains two integer numbers df and de (1 ≤ df, de ≤ 1000) — the damage a fire-tower and an electronic-tower can inflict on the Main Villain per second (in the case when the Main Villain is in the action radius of the tower). The numbers are separated with single space.

Output

Print the only real number — the maximum possible damage to the Main Villain with absolute or relative error not more than 10 - 6.

Examples

Input

1 0 0
10 10 10
100 100


Output

1989.97487421

Input

1 0 1
10 10 10
100 100


Output

3979.94974843

Note

In the first sample we've got one fire-tower that always inflicts the same damage, independently of its position. 

In the second sample we've got another freezing-tower of the same action radius. If we build the two towers opposite each other, then the Main Villain's speed will be two times lower, whenever he enters the fire-tower's action radius. That means that the enemy will be inflicted with twice more damage.

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
template <typename _T>
using pair2 = pair<_T, _T>;
template <typename _T>
using pair3 = pair<pair<_T, _T>, _T>;
template <typename _T>
using pair4 = pair<pair<_T, _T>, pair<_T, _T> >;
template <typename _T>
using priq = priority_queue<_T>;
template <typename _T>
using qrip = priority_queue<_T, vector<_T>, greater<_T> >;
const long double pi = acosl(-1);
const int Inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3fll;
unsigned Rand() { return rand() * 32768 + rand(); }
int rand(int a, int b) { return Rand() % (b - a + 1) + a; }
template <typename _T>
inline _T chmin(_T& a, _T b) {
  return a > b ? (a = b) : a;
}
template <typename _T>
inline _T chmax(_T& a, _T b) {
  return a < b ? (a = b) : a;
}
template <typename _T, int len>
struct BIT {
  _T dt[len];
  inline void add(int a, _T x) {
    while (a < len) {
      dt[a] += x;
      a += a & -a;
    }
  }
  inline void add(int l, int r, _T x) {
    add(l, x);
    add(r + 1, -x);
  }
  inline _T get(int a) {
    _T ans = 0;
    while (a) {
      ans += dt[a];
      a -= a & -a;
    }
    return ans;
  }
  inline _T get(int l, int r) { return get(r) - get(l - 1); }
};
template <typename _T, int len>
struct segbit {
  _T dt[2][len];
  inline void add(int a, _T x) {
    int b = a;
    while (a < len) {
      dt[0][a] += x;
      dt[1][a] += x * b;
      a += a & -a;
    }
  }
  inline void add(int l, int r, _T x) {
    add(l, x);
    add(r + 1, -x);
  }
  inline _T sum(int a) {
    _T ans = 0;
    int b = a;
    while (a) {
      ans += (b + 1) * dt[0][a] - dt[1][a];
      a -= a & -a;
    }
    return ans;
  }
  inline _T sum(int l, int r) { return sum(r) - sum(l - 1); }
};
struct fastIO {
  inline fastIO operator>>(int& num) {
    num = 0;
    char c = getchar();
    while (c != '-' && (c < '0' || c > '9')) c = getchar();
    bool foo = 0;
    if (c == '-') {
      foo = 1;
      c = getchar();
    }
    while (c >= '0' && c <= '9') {
      num = (num << 3) + (num << 1) + c - '0';
      c = getchar();
    }
    if (foo) num = -num;
    return *this;
  }
  inline fastIO operator>>(long long& num) {
    num = 0;
    char c = getchar();
    while (c != '-' && (c < '0' || c > '9')) c = getchar();
    bool foo = 0;
    if (c == '-') {
      foo = 1;
      c = getchar();
    }
    while (c >= '0' && c <= '9') {
      num = (num << 3) + (num << 1) + c - '0';
      c = getchar();
    }
    if (foo) num = -num;
    return *this;
  }
  inline fastIO operator>>(float& num) {
    scanf("%f", &num);
    return *this;
  }
  inline fastIO operator>>(double& num) {
    scanf("%lf", &num);
    return *this;
  }
  inline fastIO operator>>(long double& num) {
    scanf("%Lf", &num);
    return *this;
  }
  inline fastIO operator>>(char& num) {
    num = getchar();
    while (num == ' ' || num == '\n') num = getchar();
    return *this;
  }
  inline fastIO operator>>(char* num) {
    int cnt = 0;
    char c = getchar();
    while (c == ' ' || c == '\n') c = getchar();
    while (c != ' ' && c != '\n') {
      num[cnt++] = c;
      c = getchar();
    }
    num[cnt] = 0;
    return *this;
  }
  inline fastIO operator>>(string& num) {
    cin >> num;
    return *this;
  }
  inline void printInt(const int& num) {
    if (num < 10) {
      putchar(num + '0');
      return;
    }
    printInt(num / 10);
    putchar((num % 10) + '0');
  }
  inline void printll(const long long& num) {
    if (num < 10) {
      putchar(num + '0');
      return;
    }
    printll(num / 10);
    putchar((num % 10) + '0');
  }
  inline fastIO operator<<(const int& num) {
    if (num < 0)
      putchar('-'), printInt(-num);
    else
      printInt(num);
    return *this;
  }
  inline fastIO operator<<(const long long& num) {
    if (num < 0)
      putchar('-'), printll(-num);
    else
      printll(num);
    return *this;
  }
  inline fastIO operator<<(const float& num) {
    printf("%.10f", num);
    return *this;
  }
  inline fastIO operator<<(const double& num) {
    printf("%.16lf", num);
    return *this;
  }
  inline fastIO operator<<(const long double& num) {
    printf("%.20Lf", num);
    return *this;
  }
  inline fastIO operator<<(const char& num) {
    putchar(num);
    return *this;
  }
  inline fastIO operator<<(const char* num) {
    for (int i = 0; num[i]; i++) putchar(num[i]);
    return *this;
  }
  inline fastIO operator<<(const string& num) {
    cout << num;
    return *this;
  }
  template <typename _T>
  inline fastIO operator<<(const vector<_T>& vec) {
    printf("{ ");
    for (__typeof(vec.begin()) i = vec.begin(); i != vec.end(); i++)
      operator<<(*i) << ' ';
    printf("}");
    return *this;
  }
} fio;
const long double eps = 1e-10;
struct point {
  long double x, y;
  long double ang;
  point() {}
  point(long double x, long double y) : x(x), y(y) { ang = atan2l(y, x); }
  inline point operator+(const point& pt) const {
    return point(x + pt.x, y + pt.y);
  }
  inline point operator-(const point& pt) const {
    return point(x - pt.x, y - pt.y);
  }
  inline point operator*(const long double& a) const {
    return point(x * a, y * a);
  }
  inline point operator/(const long double& a) const {
    return point(x / a, y / a);
  }
  inline long double operator*(const point& pt) const {
    return x * pt.x + y * pt.y;
  }
  inline long double operator%(const point& pt) const {
    return x * pt.y - y * pt.x;
  }
  inline long double length() const { return x * x + y * y; }
  inline long double operator^(const point& pt) const {
    return acosl(*this * pt) / length() / pt.length();
  }
  inline long double getangle() { return ang = atan2l(y, x); }
  inline bool operator<(const point& p) const { return ang < p.ang; }
};
inline bool xsmaller(const point& x, const point& y) {
  return fabs(x.x - y.x) < 1e-10 ? x.y < y.y : x.x < y.x;
}
inline bool ysmaller(const point& x, const point& y) {
  return fabs(x.y - y.y) < 1e-10 ? x.x < y.x : x.y < y.y;
}
struct line {
  point a, b;
  line() {}
  line(point a, point b) : a(a), b(b) {}
};
point intersect(line x, line y) {
  point p1 = x.a, v1 = x.b - x.a;
  point p2 = y.a, v2 = y.b - y.a;
  return p1 + v1 * (((p2 - p1) % v2) / (v1 % v2));
}
const int jt = 998244353;
inline int ksmii(int a, int b = jt - 2) {
  if (b < 0) {
    return ksmii(ksmii(a), -b);
  }
  if (!b) {
    return 1;
  }
  int x = ksmii(a, b >> 1);
  x = 1ll * x * x % jt;
  if (b & 1) x = 1ll * x * a % jt;
  return x;
}
template <int len>
struct bitmod {
  int dt[len];
  inline void add(int a, int x) {
    while (a < len) {
      dt[a] = (dt[a] + x) % jt;
      a += a & -a;
    }
  }
  inline void add(int l, int r, int x) {
    add(l, x % jt);
    add(r + 1, jt - x % jt);
  }
  inline int get(int a) {
    int ans = 0;
    while (a) {
      ans = (ans + dt[a]) % jt;
      a -= a & -a;
    }
    return ans;
  }
  inline int get(int l, int r) { return (get(r) - get(l - 1) + jt) % jt; }
};
template <int len>
struct DSU {
  int fa[len];
  DSU() {
    for (int i = 0; i < (len); i++) fa[i] = i;
  }
  void init() {
    for (int i = 0; i < (len); i++) fa[i] = i;
  }
  int root(int x) { return fa[x] == x ? x : (fa[x] = root(fa[x])); }
  bool conn(int a, int b) {
    a = root(a);
    b = root(b);
    if (a == b) return 0;
    fa[a] = b;
    return 1;
  }
};
template <typename _T>
inline _T qp(_T a, int b) {
  if (!b) {
    return 1;
  }
  _T x = qp(a, b >> 1);
  x = x * x;
  if (b & 1) {
    x = x * a;
  }
  return x;
}
template <int R, int C = R>
struct matrix {
  int mat[R][C];
  int* operator[](int x) { return mat[x]; }
  matrix() {
    for (int i = 0; i < (R); i++)
      for (int j = 0; j < (C); j++) mat[i][j] = 0;
  }
  matrix(int x) {
    for (int i = 0; i < (R); i++)
      for (int j = 0; j < (C); j++) mat[i][j] = (i == j ? x : 0);
  }
  matrix<R, C> operator+(const matrix<R, C> m) {
    matrix<R, C> ans;
    for (int i = 0; i < (R); i++)
      for (int j = 0; j < (C); j++)
        ans.mat[i][j] = (mat[i][j] + m.mat[i][j]) % jt;
    return ans;
  }
  template <int D>
  matrix<R, D> operator*(const matrix<C, D> m) {
    matrix<R, D> ans;
    for (int i = 0; i < (R); i++)
      for (int j = 0; j < (C); j++)
        for (int k = 0; k < (D); k++)
          ans.mat[i][k] =
              (ans.mat[i][k] + ((long long)mat[i][j]) * m.mat[j][k]) % jt;
    return ans;
  }
  void debug() {
    for (int i = 0; i < (R); i++) {
      for (int j = 0; j < (C); j++)
        if (0) cout << mat[i][j] << ' ';
      if (0) cout << endl;
    }
    if (0) cout << endl;
  }
};
int nf, ne, ns;
double rf, re, rs;
int df, de;
int n;
vector<double> cha;
int main() {
  fio >> nf >> ne >> ns >> rf >> re >> rs >> df >> de;
  rf = sqrt(rf * rf - 1);
  re = sqrt(re * re - 1);
  rs = sqrt(rs * rs - 1);
  n = nf + ne + ns;
  double ans = 0;
  for (int i = 0; i < ((1ll << (n))); i++) {
    if (__builtin_popcount(i) != ns) {
      continue;
    }
    double res = 0;
    cha.clear();
    for (int j = 0; j < (n); j++) {
      if (!(((i) >> (j)) & 1)) {
        int posf = j / 2;
        double damf = rf * df * 2, dame = re * de * 2;
        for (int k = 0; k < (n); k++) {
          if ((((i) >> (k)) & 1)) {
            int poss = k / 2;
            damf +=
                max(.0, min(poss + rs, posf + rf) - max(poss - rs, posf - rf)) *
                df;
            dame +=
                max(.0, min(poss + rs, posf + re) - max(poss - rs, posf - re)) *
                de;
          }
        }
        res += damf;
        cha.push_back(damf - dame);
      }
    }
    sort(cha.begin(), cha.end());
    for (int j = 0; j < (ne); j++) {
      res -= cha[j];
    }
    ans = max(ans, res);
  }
  fio << ans << '\n';
  return 0;
}