#include <bits/stdc++.h>
using namespace std;
constexpr double EPS = 1e-9;
struct point {
  double x, y;
  explicit point(double x_ = 0.0, double y_ = 0.0) : x(x_), y(y_) {}
  point(const point &p) : x(p.x), y(p.y) {}
  point operator+(const point &p) const { return point(x + p.x, y + p.y); }
  point operator-(const point &p) const { return point(x - p.x, y - p.y); }
  point operator*(double s) const { return point(x * s, y * s); }
  point operator*(const point &p) const {
    return point(x * p.x - y * p.y, x * p.y + y * p.x);
  }
  point operator/(double s) const { return point(x / s, y / s); }
};
double norm(const point &p) { return p.x * p.x + p.y * p.y; }
double abs(const point &p) { return sqrt(norm(p)); }
double cross(const point &a, const point &b) { return a.x * b.y - a.y * b.x; }
struct circle {
  point c;
  double r;
  circle(const point &c_, const double &r_) : c(c_), r(r_) {}
};
bool intersect(const circle &c, const circle &d) {
  return abs(c.c - d.c) < c.r + d.r + EPS &&
         abs(c.c - d.c) + EPS > abs(c.r - d.r);
}
vector<point> crosspoint(const circle &c, const circle &d) {
  vector<point> res;
  if (abs(c.c - d.c) < EPS) return res;
  const double tmp = abs(c.c - d.c);
  const double rc = (tmp * tmp + c.r * c.r - d.r * d.r) / (tmp + tmp);
  const double rs = sqrt(c.r * c.r - rc * rc);
  const point diff = (d.c - c.c) / tmp;
  res.emplace_back(c.c + diff * point(rc, rs));
  res.emplace_back(c.c + diff * point(rc, -rs));
  return res;
}
const string NG = "impossible";
double arg(point a, point b, const point &base = point(0, 0)) {
  a = a - base;
  b = b - base;
  const double x = abs(a);
  const double y = abs(b);
  const double z = abs(a - b);
  return acos((x * x + y * y - z * z) / (2 * x * y));
}
double common_area(const circle &a, const circle &b) {
  const auto cp = crosspoint(a, b);
  if (cp.empty()) return min(a.r * a.r * 2 * M_PI, b.r * b.r * 2 * M_PI);
  if (!intersect(a, b)) return 0;
  const double theta = arg(cp.front(), b.c, a.c);
  return a.r * a.r * theta + b.r * b.r * theta -
         abs(cross(cp.front() - b.c, a.c - b.c));
}
inline string solve(int w, int h, int A, int B, int A_B) {
  const int S = w * h;
  if (S <= A || S <= B) return NG;
  bool change = false;
  double ra = sqrt(A / M_PI);
  double rb = sqrt(B / M_PI);
  if (ra < rb) {
    swap(ra, rb);
    change = true;
  }
  if (min(w, h) < ra || min(w, h) < rb) return NG;
  circle a(point(ra, ra), ra);
  circle b(point(w - rb, h - rb), rb);
  if (A_B < common_area(a, b)) return NG;
  point L(ra, ra), R(w - rb, h - rb);
  for (int i = 0; i < 200; ++i) {
    const point M = (L + R) * 0.5;
    if (common_area(a, circle(M, rb)) < A_B) {
      R = M;
    } else {
      L = M;
    }
  }
  b.c = L;
  if (change) swap(a, b);
  ostringstream oss;
  oss << a.c.x << ' ' << a.c.y << ' ' << a.r << ' ';
  oss << b.c.x << ' ' << b.c.y << ' ' << b.r;
  return oss.str();
}
int main() {
  cin.tie(nullptr);
  ios::sync_with_stdio(false);
  cout.setf(ios::fixed);
  cout.precision(10);
  for (int w, h, A, B, A_B; cin >> w >> h >> A >> B >> A_B && w;) {
    cout << solve(w, h, A, B, A_B) << endl;
  }
  return EXIT_SUCCESS;
}
