#include <bits/stdc++.h>
using namespace std;
const int iINF = 1L << 30;
const long long lINF = 1LL << 60;
const double EPS = 1e-9;
typedef struct Point {
  double x, y;
  Point(double _x, double _y) : x(_x), y(_y) {}
} Vector;
Point operator+(const Point& _a, const Point& _b) {
  return Point(_a.x + _b.x, _a.y + _b.y);
}
Point operator-(const Point& _a, const Point& _b) {
  return Point(_a.x - _b.x, _a.y - _b.y);
}
Point operator*(const Point& _a, const Point& _b) {
  return Point(_a.x * _b.x, _a.y * _b.y);
}
Point operator/(const Point& _a, const Point& _b) {
  return Point(_a.x / _b.x, _a.y / _b.y);
}
Point operator*(const Point& _a, double _b) {
  return Point(_a.x * _b, _a.y * _b);
}
Point operator/(const Point& _a, double _b) {
  return Point(_a.x / _b, _a.y / _b);
}
bool operator<(const Point& _a, const Point& _b) {
  return _a.x != _b.x ? _a.x < _b.x : _a.y < _b.y;
}
bool operator>(const Point& _a, const Point& _b) { return _b < _a; }
bool operator==(const Point& _a, const Point& _b) {
  return fabs(_a.x - _b.x) < EPS && fabs(_a.y - _b.y) < EPS;
}
double norm(const Point& _a) { return _a.x * _a.x + _a.y * _a.y; }
double abs(const Point& _a) { return sqrt(norm(_a)); }
double dot(const Vector& _a, const Vector& _b) {
  return _a.x * _b.x + _a.y * _b.y;
}
double cross(const Point& _a, const Point& _b) {
  return _a.x * _b.y - _a.y * _b.x;
}
double dist(const Point& _a, const Point& _b) { return abs(_a - _b); }
bool is_vertical(const Vector& _a, const Vector& _b) {
  return fabs(dot(_a, _b)) < EPS;
}
bool is_parrallel(const Vector& _a, const Vector& _b) {
  return fabs(cross(_a, _b)) < EPS;
}
Vector unit_vector(const Vector& _a) { return _a / abs(_a); }
pair<Vector, Vector> normal_vectors(const Vector& _a) {
  return make_pair(Vector(_a.y, -_a.x), Vector(-_a.y, _a.x));
}
pair<Vector, Vector> normal_unit_vectors(const Vector& _a) {
  pair<Vector, Vector> pvv = normal_vectors(_a);
  return make_pair(unit_vector(pvv.first), unit_vector(pvv.second));
}
double cosign(const Vector& _a, const Vector& _b) {
  return dot(_a, _b) / (abs(_a) * abs(_b));
}
double sign(const Vector& _a, const Vector& _b) {
  return cross(_a, _b) / (abs(_a) * abs(_b));
}
double arg(double _a, double _b, double _c) {
  return acos((_b * _b + _c * _c - _a * _a) / (2.0 * _b * _c));
}
Point rotate(const Vector& _v, double _s) {
  return Vector(_v.x * cos(_s) - _v.y * sin(_s),
                _v.x * sin(_s) + _v.y * cos(_s));
}
double area_tri(const Point& _a, const Point& _b, const Point& _c) {
  Vector ac = _a - _c, bc = _b - _c;
  return cross(ac, bc) / 2.;
}
int ccw(const Point& _a, const Point& _b, const Point& _c) {
  Vector ba = _b - _a, ca = _c - _a;
  if (cross(ba, ca) > EPS) return +1;
  if (cross(ba, ca) < -EPS) return -1;
  if (dot(ba, ca) < -EPS) return +2;
  if (abs(ba) + EPS < abs(ca)) return -2;
  return 0;
}
typedef struct Line {
  Point s, e;
  Line(Point _s, Point _e) : s(_s), e(_e) {}
} Segment;
double dist_point_line(const Point& _p, const Line& _l) {
  return fabs(cross(_p - _l.s, _l.e - _l.s)) / abs(_l.e - _l.s);
}
double dist_point_seg(const Point& _p, const Segment& _s) {
  if (dot(_s.e - _s.s, _p - _s.s) < EPS) return abs(_p - _s.s);
  if (dot(_s.s - _s.e, _p - _s.e) < EPS) return abs(_p - _s.e);
  return dist_point_line(_p, _s);
}
double dist_seg_seg(const Segment& _a, const Segment& _b) {
  double res = dist_point_seg(_b.s, _a);
  res = min(res, dist_point_seg(_b.e, _a));
  res = min(res, dist_point_seg(_a.s, _b));
  res = min(res, dist_point_seg(_a.e, _b));
  return res;
}
bool is_cross(const Segment& _a, const Segment& _b) {
  return (ccw(_a.s, _a.e, _b.s) * ccw(_a.s, _a.e, _b.e) <= 0 &&
          ccw(_b.s, _b.e, _a.s) * ccw(_b.s, _b.e, _a.e) <= 0);
}
bool is_parrallel(const Segment& _a, const Segment& _b) {
  return is_parrallel(_a.s - _a.e, _b.s - _b.e);
}
Point cross_point(const Line& _a, const Line& _b) {
  double d1 = cross(_b.e - _b.s, _b.s - _a.s);
  double d2 = cross(_b.e - _b.s, _a.e - _a.s);
  return _a.s + (_a.e - _a.s) * d1 / d2;
}
bool point_on_line(const Point& _p, const Line& _l) {
  return ((ccw(_l.s, _l.e, _p) + 2) % 2 == 0);
}
bool point_on_seg(const Point& _p, const Segment& _s) {
  return (ccw(_s.s, _s.e, _p) == 0);
}
struct Circle {
  Point c;
  double r;
  Circle(Point _c, double _r) : c(_c), r(_r) {}
  double area() const { return M_PI * r * r; }
};
int circle_intersect(const Circle& _a, const Circle& _b) {
  double _d = abs(_a.c - _b.c);
  if (_a.r + _b.r + EPS < _d) return 0;
  if (_b.r + _d + EPS < _a.r) return -3;
  if (_a.r + _d + EPS < _b.r) return -4;
  if (fabs(_a.r + _b.r - _d) < EPS) return 1;
  if (fabs(_b.r + _d - _a.r) < EPS) return 3;
  if (fabs(_a.r + _d - _b.r) < EPS) return 4;
  return 2;
}
vector<Point> cross_point(const Circle& _a, const Circle& _b) {
  vector<Point> res;
  Point _x = unit_vector(_b.c - _a.c) * _a.r;
  int ci = circle_intersect(_a, _b);
  if (ci > 0) {
    if (ci != 2) {
      res.push_back(_a.c + _x);
    } else {
      double _s = arg(_b.r, abs(_b.c - _a.c), _a.r);
      res.push_back(_a.c + rotate(_x, _s));
      res.push_back(_a.c + rotate(_x, -_s));
    }
  }
  return res;
}
vector<Point> cross_point(const Circle _a, const Line& _l) {
  vector<Point> res;
  Point _n = normal_vectors(_l.s - _l.e).first;
  Point _p = cross_point(_l, Line(_a.c, _a.c + _n));
  if (abs(abs(_a.c - _p) - _a.r) < EPS) {
    res.push_back(_p);
  } else if (abs(_a.c - _p) + EPS < _a.r) {
    double len = sqrt(_a.r * _a.r - norm(_a.c - _p));
    Point cp = unit_vector(_l.s - _l.e) * len;
    res.push_back(_p + cp);
    res.push_back(_p - cp);
  }
  return res;
}
double area_of_circle_intersect(const Circle& _a, const Circle& _b) {
  int ci = circle_intersect(_a, _b);
  if (ci == 0 || ci == 1) return 0.0;
  if (ci == 3 || ci == -3) return _b.area();
  if (ci == 4 || ci == -4) return _a.area();
  double _d = abs(_a.c - _b.c);
  double s1 = arg(_b.r, _a.r, _d), s2 = arg(_a.r, _b.r, _d);
  double tri = (_a.r * _a.r * sin(2.0 * s1) + _b.r * _b.r * sin(2.0 * s2)) / 2.;
  return _a.r * _a.r * s1 + _b.r * _b.r * s2 - tri;
}
struct Polygon {
  vector<Point> vert;
  Polygon(int _size = 3) : vert(_size, Point(0, 0)) {}
  int size() const { return (int)vert.size(); }
  Point at(int i) const {
    i %= size();
    return vert[i];
  }
  double area() const {
    double res = 0;
    for (int i = 0; i < size(); ++i) res += cross(at(i), at(i + 1));
    return fabs(res) / 2.;
  }
};
double Uw, Uh, A, B, A_B;
double rA, rB;
double calc_rad(double S) { return sqrt(S / M_PI); }
void solve() {
  rA = calc_rad(A);
  rB = calc_rad(B);
  bool rot = false;
  if (Uw < Uh) {
    swap(Uw, Uh);
    rot = true;
  }
  if (rA > Uh || rB > Uh) {
    cout << "impossible" << endl;
    return;
  }
  Circle a(Point(rA + 0.01, max(rA, rB) + 0.01), rA),
      b(Point(Uw - rB - 0.01, max(rA, rB) + 0.01), rB);
  double init_S = area_of_circle_intersect(a, b);
  int ci = circle_intersect(a, b);
  if (A_B < EPS) {
    if (ci == 0 || ci == 1) {
      if (rot) {
        printf("%.9lf %.9lf %.9lf %.9lf %.9lf %.9lf\n", a.c.y, a.c.x, a.r,
               b.c.y, b.c.x, b.r);
      } else {
        printf("%.9lf %.9lf %.9lf %.9lf %.9lf %.9lf\n", a.c.x, a.c.y, a.r,
               b.c.x, b.c.y, b.r);
      }
      return;
    } else {
      cout << "impossible" << endl;
      return;
    }
  }
  if (init_S - A_B > 0.0) {
    cout << "impossible" << endl;
    return;
  }
  Vector ba = b.c - a.c;
  double lb = 0.0, ub = Uw - rB - rA + 1.0;
  for (int rep = 0; rep < 1000; ++rep) {
    double med = (ub + lb) / 2.;
    b.c = a.c + (ba * med);
    double S = area_of_circle_intersect(a, b);
    if (A_B - S > 0.0)
      ub = med;
    else
      lb = med;
  }
  if (rot) {
    printf("%.9lf %.9lf %.9lf %.9lf %.9lf %.9lf\n", a.c.y, a.c.x, a.r, b.c.y,
           b.c.x, b.r);
  } else {
    printf("%.9lf %.9lf %.9lf %.9lf %.9lf %.9lf\n", a.c.x, a.c.y, a.r, b.c.x,
           b.c.y, b.r);
  }
}
int main() {
  while (cin >> Uw >> Uh >> A >> B >> A_B, Uw) {
    solve();
  }
  return 0;
}
