#include <bits/stdc++.h>
using namespace std;
using lint = long long;
template<class T = int> using V = vector<T>;
template<class T = int> using VV = V< V<T> >;

using R = long double;
constexpr R pi = acos((R)-1), eps = 1e-10;

int sgn(R a) { return (a > eps) - (a < -eps); }
int sgn(R a, R b) { return sgn(a - b); }
using P = complex<R>;
istream& operator>>(istream& i, P& p) { R x, y; i >> x >> y; p = P(x, y); return i; }
ostream& operator<<(ostream& o, P p) { return o << fixed << setprecision(15) << real(p) << ' ' << imag(p); }
bool cmp(P p, P q) { return 2 * sgn(real(p), real(q)) + sgn(imag(p), imag(q)) < 0; }
bool eql(P p, P q) { return !cmp(p, q) and !cmp(q, p); }
R dot(P p, P q) { return real(conj(p) * q); }
R crs(P p, P q) { return imag(conj(p) * q); }
// -2: back, -1: cw, 0: on, 1: ccw, 2: front
int ccw(P p, P q) {
  int s = sgn(crs(p, q));
  if (s) return s;
  if (dot(p, q) < 0) return -2;
  if (dot(p, q - p) > 0) return 2;
  return 0;
}
int ccw(P o, P p, P q) { return ccw(p - o, q - o); }
struct L {
  P s, t;
  P vec() const { return t - s; }
  R abs() const { return std::abs(vec()); }
  R arg() const { return std::arg(vec()); }
};
int ccw(L s, P p) { return ccw(s.s, s.t, p); }

P proj(P p, L l) {
  P e = l.vec() / l.abs();
  return l.s + dot(p - l.s, e) * e;
}
P refl(P p, L l) { return (R)2 * proj(p, l) - p; }
R distPP(P p, P q) { return abs(q - p); }
R distPL(P p, L l) { return distPP(p, proj(p, l)); }
R distPS(P p, L s) {
  P q = proj(p, s);
  if (!ccw(s, q)) return distPP(p, q);
  return min(distPP(p, s.s), distPP(p, s.t));
}
R distLL(L l, L m) {
  if (sgn(crs(l.vec(), m.vec()))) return 0;
  return distPL(l.s, m);
}
R distLS(L l, L s) {
  if (ccw(l, s.s) * ccw(l, s.t) != 1) return 0;
  return min(distPL(s.s, l), distPL(s.t, l));
}
R distSS(L s, L t) {
  if (ccw(s, t.s) * ccw(s, t.t) <= 0 and ccw(t, s.s) * ccw(t, s.t) <= 0) return 0;
  return min({distPS(s.s, t), distPS(s.t, t), distPS(t.s, s), distPS(t.t, s)});
}
P intxn(L l, L m) {
  assert(sgn(crs(l.vec(), m.vec())));
  return l.s + crs(m.s - l.s, m.vec()) / crs(l.vec(), m.vec()) * l.vec();
}

struct C { P o; R r; };
V<P> intxnCL(C c, L l) {
  int s = sgn(distPL(c.o, l), c.r);
  if (s > 0) return {};
  P p = proj(c.o, l);
  if (!s) return {p};
  P q = sqrt(c.r * c.r - norm(p - c.o)) * l.vec() / l.abs();
  return {p - q, p + q};
}
V<P> intxnCC(C c, C d) {
  R a = distPP(c.o, d.o);
  if (!sgn(a)) {
    assert(sgn(c.r, d.r));
    return {};
  }
  if (sgn(a, abs(d.r - c.r)) < 0 or sgn(a, c.r + d.r) > 0) return {};
  if (!sgn(a, abs(d.r - c.r)) or !sgn(a, c.r + d.r)) return {c.o + c.r * (d.o - c.o) / abs(d.o - c.o)};
  P p = polar(c.r / a, acos((a * a + c.r * c.r - d.r * d.r) / (2 * a * c.r)));
  return {c.o + conj(p) * (d.o - c.o), c.o + p * (d.o - c.o)};
}
R areaCC(C c, C d) {
  R a = distPP(c.o, d.o);
  if (sgn(a, abs(d.r - c.r)) <= 0) return pi * min(c.r * c.r, d.r * d.r);
  if (sgn(a, c.r + d.r) >= 0) return 0;
  R tc = acos((a * a + c.r * c.r - d.r * d.r) / (2 * a * c.r));
  R td = acos((a * a + d.r * d.r - c.r * c.r) / (2 * a * d.r));
  return c.r * c.r * (tc - sin(2 * tc) / 2) + d.r * d.r * (td - sin(2 * td) / 2);
}

V<string> split(const string& s, char c) {
  V<string> res;
  stringstream ss(s);
  string t;
  while (getline(ss, t, c)) res.push_back(t);
  return res;
}

int main() {
  cin.tie(nullptr); ios::sync_with_stdio(false);
  /*{
    string s;
    while (getline(cin, s)) {
      if (s == "impossible") {
        cout << -1 << '\n';
        continue;
      }
      auto ss = split(s, ' ');
      C c{{stold(ss[0]), stold(ss[1])}, stold(ss[2])};
      C d{{stold(ss[3]), stold(ss[4])}, stold(ss[5])};
      cout << areaCC(c, d) << '\n';
    }
    return 0;
  }*/
  while (true) {
    bool b = false;
    int w, h, na, nb, nab; cin >> w >> h >> na >> nb >> nab;
    if (na < nb) {
      swap(na, nb);
      b = true;
    }
    if (!w) break;
    auto area2r = [](R S) -> R { return sqrt(S / pi); };
    R ra = area2r(na);
    R rb = area2r(nb);
    if (sgn(2 * max(ra, rb), min(w, h)) > 0) {
      cout << "impossible" << '\n';
      continue;
    }
    P p(rb, rb), q(w - rb, h - rb);
    // if (sgn(areaCC({{ra, ra}, ra}, {q, rb}), nab) > 0) {
    //   cout << "impossible" << '\n';
    //   continue;
    // }
    [&] {
      for (int _ = 0; _ < 1000; ++_) {
        P m = (p + q) / (R)2;
        int s = sgn(areaCC({{ra, ra}, ra}, {m, rb}), nab);
        if (!s) {
          if (b) {
            cout << real(m) << ' ' << imag(m) << ' ' << rb << ' ';
            cout << fixed << setprecision(9) << ra << ' ' << ra << ' ' << ra << '\n';
          } else {
            cout << fixed << setprecision(9) << ra << ' ' << ra << ' ' << ra << ' ';
            cout << real(m) << ' ' << imag(m) << ' ' << rb << '\n';
          }
          return;  
        }
        (s > 0 ? p : q) = m;
      }
      cout << "impossible" << '\n';
    }();
  }
}


Measured memory_bytes: 3460