#include <bits/stdc++.h>
using namespace std;
using VI = vector<int>;
using VVI = vector<VI>;
using PII = pair<int, int>;
using LL = long long;
using VL = vector<LL>;
using VVL = vector<VL>;
using PLL = pair<LL, LL>;
using VS = vector<string>;
template <class S, class T>
istream& operator>>(istream& is, pair<S, T>& p) {
  return is >> p.first >> p.second;
}
template <class S, class T>
ostream& operator<<(ostream& os, const pair<S, T>& p) {
  return os << p.first << " " << p.second;
}
template <class T>
void maxi(T& x, T y) {
  if (x < y) x = y;
}
template <class T>
void mini(T& x, T y) {
  if (x > y) x = y;
}
const double EPS = 1e-6;
const double PI = acos(-1.0);
const LL MOD = 1e9 + 7;
class Point {
 public:
  double x, y;
  Point(double x = 0.0, double y = 0.0) : x(x), y(y) {}
  Point& operator+=(const Point& p) {
    x += p.x;
    y += p.y;
    return *this;
  }
  Point operator+(const Point& p) const {
    Point q = *this;
    return q += p;
  }
  Point& operator-=(const Point& p) {
    x -= p.x;
    y -= p.y;
    return *this;
  }
  Point operator-(const Point& p) const {
    Point q = *this;
    return q -= p;
  }
  Point& operator*=(double a) {
    x *= a;
    y *= a;
    return *this;
  }
  Point operator*(double a) const {
    Point q = *this;
    return q *= a;
  }
  Point& operator/=(double a) {
    x /= a;
    y /= a;
    return *this;
  }
  Point operator/(double a) const {
    Point q = *this;
    return q /= a;
  }
  double abs() const { return sqrt(norm()); }
  double norm() const { return x * x + y * y; }
  Point& normalize() { return *this /= abs(); }
  bool operator<(const Point& p) const { return x != p.x ? x < p.x : y < p.y; }
  bool operator==(const Point& p) const {
    return fabs(x - p.x) < EPS && fabs(y - p.y) < EPS;
  }
  friend ostream& operator<<(ostream& os, const Point& p);
};
ostream& operator<<(ostream& os, const Point& p) {
  return os << "(" << p.x << "," << p.y << ")";
}
class Segment {
 public:
  Point p1, p2;
  Segment() {}
  Segment(const Point& p1_, const Point& p2_) : p1(p1_), p2(p2_) {}
};
class Circle {
 public:
  Point c;
  double r;
  double area() const { return r * r * PI; }
};
double dot(Point a, Point b) { return a.x * b.x + a.y * b.y; }
double cross(Point a, Point b) { return a.x * b.y - a.y * b.x; }
Point project(Segment s, Point p) {
  Point base = s.p2 - s.p1;
  double r = dot(p - s.p1, base) / base.norm();
  return s.p1 + base * r;
}
Point rotate(Point p, double angle) {
  return Point(p.x * cos(angle) - p.y * sin(angle),
               p.x * sin(angle) + p.y * cos(angle));
}
pair<Point, Point> getCrossPoints(const Circle& c1, const Circle& c2) {
  double d = (c2.c - c1.c).abs();
  double a = (c1.r * c1.r + d * d - c2.r * c2.r) / (2 * d);
  Point e = (c2.c - c1.c) / d;
  Point h = rotate(e, PI / 2) * sqrt(max(c1.r * c1.r - a * a, 0.));
  if (d + min(c1.r, c2.r) <= max(c1.r, c2.r))
    return make_pair(c1.c + e * c1.r, c1.c + e * c1.r);
  return make_pair(c1.c + e * a + h, c1.c + e * a - h);
}
double getDistanceLP(Segment l, Point p) {
  return abs(cross(l.p2 - l.p1, p - l.p1) / (l.p2 - l.p1).abs());
}
double getArea(Circle c1, Circle c2) {
  if (c2.r > c1.r) swap(c2, c1);
  Point dr = c2.c - c1.c;
  Segment ldr;
  ldr.p1 = c1.c;
  ldr.p2 = c2.c;
  double sr = (c1.r + c2.r);
  if (dr.norm() > sr * sr) return 0.;
  if (dr.abs() + c2.r <= c1.r) return c2.area();
  auto cp = getCrossPoints(c1, c2);
  Segment lcp;
  lcp.p1 = cp.first;
  lcp.p2 = cp.second;
  double d = getDistanceLP(lcp, c1.c);
  dr.normalize();
  Point v = (cp.first - c1.c).normalize();
  double theta = acos(dot(dr, v));
  double res = c1.r * c1.r * theta - d * c1.r * sin(theta);
  d = getDistanceLP(lcp, c2.c);
  dr = (c1.c - c2.c).normalize();
  v = (cp.first - c2.c).normalize();
  theta = acos(dot(dr, v));
  res += c2.r * c2.r * theta - d * c2.r * sin(theta);
  return res;
}
int W, H, A, B, AB;
bool ok(Circle& c1, Circle& c2) {
  bool isSwapped = false;
  if (c1.r < c2.r) {
    swap(c1, c2);
    isSwapped = true;
  }
  if (getArea(c1, c2) > AB + EPS) return false;
  double lb = 0., ub = (c1.c - c2.c).abs();
  Point dr = (c2.c - c1.c).normalize();
  for (int it = (0); it < (300); ++it) {
    double mid = (lb + ub) / 2.;
    c2.c = c1.c + dr * mid;
    double A = getArea(c1, c2) - AB;
    if (abs(A) < 1e-5) {
      if (isSwapped) {
        swap(c1, c2);
      }
      return true;
    } else if (A > 0) {
      lb = mid;
    } else
      ub = mid;
  }
  return false;
}
int main() {
  cin.tie(0);
  ios_base::sync_with_stdio(false);
  const string IMP = "impossible";
  while (cin >> W >> H >> A >> B >> AB, W) {
    Circle ca, cb;
    ca.r = sqrt(A / PI);
    cb.r = sqrt(B / PI);
    double R = min(W, H) / 2.;
    if (ca.r > R || cb.r > R) {
      cout << IMP << endl;
      continue;
    }
    ca.c = Point(ca.r, ca.r);
    cb.c = Point(W - cb.r, H - cb.r);
    if (ok(ca, cb)) {
      cout << fixed << setprecision(9) << ca.c.x << " " << ca.c.y << " " << ca.r
           << " " << cb.c.x << " " << cb.c.y << " " << cb.r << endl;
    } else {
      cout << IMP << endl;
    }
  }
  return 0;
}
