#include <cstdio>
#include <algorithm>
#include <iostream>
#include <cstring>
#include <cmath>
#include <complex>
#include <vector>
#include <cstdlib>
#include <cassert>

using namespace std;

#define SIZE 4010
#define INF 1000000000
#define LLINF 1000000000000000000

typedef long long ll;
typedef long double Real;
typedef complex<Real> P;

Real eps = 1e-8;


Real dot(P a, P b) {
  return (a * conj(b)).real();
}

Real cross(P a, P b) {
  return (conj(a) * b).imag();
}


int ccw(P a, P b, P c) {
  if (cross(b-a, c-a) > eps) return 1;
  if (cross(b-a, c-a) < -eps) return -1;
  if (dot(b-a, c-a) < -eps) return -2;
  if (dot(a-b, c-b) < -eps) return 2;
  return 0;
}

bool isIntersectCC(P c1, Real r1, P c2, Real r2) {
  Real dist = abs(c1 - c2);

  return abs(r1 - r2) < dist + eps && dist - eps < r1 + r2;
}

vector<P> getCrossPointCC(P c1, Real r1, P c2, Real r2) {
  if (!isIntersectCC(c1, r1, c2, r2)) return {};

  Real dist = abs(c1 - c2);
  Real a = acos((r1*r1 + dist*dist - r2 * r2) / (2 * r1 * dist));

  return {c1 + polar(r1, arg(c2 - c1) + a), c1 + polar(r1, arg(c2 - c1) - a)};
}

bool isIntersectedSS(P a1, P a2, P b1, P b2) {
  int a = ccw(b1, b2, a1);
  int b = ccw(b1, b2, a2);
  int c = ccw(a1, a2, b1);
  int d = ccw(a1, a2, b2);

  return a * b <= 0 && c * d <= 0;
}

Real getAreaCC2(P c1, Real r1, P c2, Real r2) {
  double d = abs(c1 - c2);
  if (r1 + r2 <= d + eps) {
    return 0.0;
  } else if (d <= abs(r1 - r2) + eps) {
    double r = min(r1, r2);
    return r * r * M_PI;
  } else {
    double rc = (d * d + r1 * r1 - r2 * r2) / (2 * d);
    double theta = acos(rc / r1);
    double phi = acos((d - rc) / r2);
    return r1 * r1 * theta + r2 * r2 * phi - d * r1 * sin(theta);
  }
}

Real getAreaCC(P c1, Real r1, P c2, Real r2) {
  if (abs(c1 - c2) + min({r1, r2}) < max({r1, r2}) + eps) {
    return pow(min({r1, r2}), 2) * M_PI;
  }

  if (abs(r1 + r2 - abs(c1 - c2)) < eps) return 0;

  auto v = getCrossPointCC(c1, r1, c2, r2);

  if (v.empty()) return 0;


  Real d2 = abs(v[1] - v[0]);

  if (d2 < eps) {
    return 0;
  }

  //Real theta1 = acos(-(d2*d2 - r1*r1 - r1*r1) / (2 * r1 * r1));
  //Real theta2 = acos(-(d2*d2 - r2*r2 - r2*r2) / (2 * r2 * r2));

  Real theta1 = abs(arg((v[0] - c1) / (v[1] - c1)));
  Real theta2 = abs(arg((v[0] - c2) / (v[1] - c2)));


  Real area = 0;
  if (!isIntersectedSS(v[0], v[1], c1, c2)) {
    if (r1 > r2) {
      swap(r1, r2);
      swap(c1, c2);
      swap(theta1, theta2);
    }
    area = r1 * r1 * M_PI;
    area -= r1 * r1 * theta1 / 2;
    area -= abs(cross(v[0]-c2, v[1]-c2)) / 2;
    area += abs(cross(v[0]-c1, v[1]-c1)) / 2;
    area += r2 * r2 * theta2 / 2;
  } else {
    area = - abs(cross(c1-v[0], c2-v[0]));
    area += r1 * r1 * theta1 / 2;
    area += r2 * r2 * theta2 / 2;
  }

  //assert(abs(theta1 - theta1v) < eps);
  //assert(abs(theta2 - theta2v) < eps);


  return area;
}

bool solve() {
  int W, H, A, B, AB;

  cin >> W >> H >> A >> B >> AB;
  /*
  W = rand() % 20 + 1;
  H = rand() % 20 + 1;
  A = rand() % 20 + 1;
  B = rand() % 20 + 1;
  AB = rand() % min({A, B});
  */
  if (W == 0) return false;

  Real r1 = sqrt((Real)A / M_PI);
  Real r2 = sqrt((Real)B / M_PI);

  bool f = r1 < r2;

  if (f) swap(r1, r2);

  Real d;

  if (AB == 0) {
    d = r1 + r2;
  } else if (AB == min({A, B})) {
    d = 0;
  } else {
    Real l = abs(r1 - r2), r = r1 + r2;

    for (int i=0; i<100; i++) {
      Real mid = (l + r) / 2;

      Real area = getAreaCC(P(0, 0), r1, P(0, mid), r2);

      assert(abs(area - getAreaCC2(P(0, 0), r1, P(0, mid), r2)) < eps);

      if (area < AB) {
        r = mid;
      } else {
        l = mid;
      }
    }

    d = l;
  }

  P e1 = P(r1, r1);
  P e2 = P(W-r2, H-r2);

  if (min({W, H}) < max({r1, r2}) * 2 - eps) {
    puts("impossible");
    return true;
  }

  if (abs(e1 - e2) < d - eps) {
    puts("impossible");
    return true;
  }

  P e2d = (e2 - e1) / abs(e2 - e1) * d + e1;
  /*
  printf("%.10lf %.10lf %.10lf ",  (double)e1.real(), (double)e1.imag(), (double)r1);
  printf("%.10lf %.10lf %.10lf\n", (double)e2d.real(), (double)e2d.imag(), (double)r2);

  cerr << d << endl;

  assert(abs(e1 - e2d) < abs(e1 - e2) + eps);
  assert(abs(abs(e1 - e2d) - d) < eps);
  printf("%d == %.10Lf\n", AB, getAreaCC(e1, r1, e2d, r2));
  assert(abs(getAreaCC(e1, r1, e2d, r2) - AB) < eps);
  */
  if (f) {
    swap(e1, e2d);
    swap(r1, r2);
  }

  printf("%.10lf %.10lf %.10lf ",  (double)e1.real(), (double)e1.imag(), (double)r1);
  printf("%.10lf %.10lf %.10lf\n", (double)e2d.real(), (double)e2d.imag(), (double)r2);

  //cerr << r1 << endl;
  //cerr << d << endl;
  //cerr << getAreaCC(e1, r1, e2d, r2) << endl;



  return true;
}

int main() {
  while(solve());

}



Measured memory_bytes: 3460