#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>;

#define ALL(a)  begin((a)),end((a))
#define RALL(a) (a).rbegin(), (a).rend()
#define PB push_back
#define EB emplace_back
#define MP make_pair
#define SZ(a) int((a).size())
#define SORT(c) sort(ALL((c)))
#define RSORT(c) sort(RALL((c)))
#define UNIQ(c) (c).erase(unique(ALL((c))), end((c)))

#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n)  FOR(i,0,n)

#define FF first
#define SS second
template<class S, class T>
istream& operator>>(istream& is, pair<S,T>& p){
  return is >> p.FF >> p.SS;
}
template<class S, class T>
ostream& operator<<(ostream& os, const pair<S,T>& p){
  return os << p.FF << " " << p.SS;
}
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;
  }
  
  //EPS??????????°??????????
  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;}
};
typedef Point Vector;
typedef Segment Line;
double dot(Vector a, Vector b){
	return a.x*b.x + a.y*b.y;
}
double cross(Vector a, Vector b){
	return a.x*b.y - a.y*b.x;
}
Point project(Line s, Point p){
	Vector 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);
  Vector e = (c2.c - c1.c) / d;
  Vector 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 MP(c1.c + e*c1.r, c1.c + e*c1.r);

  return MP(c1.c + e*a + h, c1.c + e*a - h);
}
double getDistanceLP(Line 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);

  Vector dr = c2.c - c1.c;
  double sr = (c1.r + c2.r);
  if(dr.norm() > sr*sr) return 0.;
  if(dr.abs() + c2.r <= c1.r)
	return c2.area();

  double theta1 = acos((c1.r*c1.r + dr.norm() - c2.r*c2.r) / (2*c1.r*dr.abs()));
  double theta2 = acos((c2.r*c2.r + dr.norm() - c1.r*c1.r) / (2*c2.r*dr.abs()));
  double res = theta1*c1.r*c1.r + theta2*c2.r*c2.r;
  double s = (c1.r + c2.r + dr.abs()) / 2.;
  res -= 2*sqrt(s*(s-c1.r)*(s-c2.r)*(s-dr.abs()));

  return res;
}
int W, H, A, B, AB;
bool ok(Circle& c1, Circle& c2){
  if(getArea(c1, c2) > AB+EPS) return false;

  bool isSwapped = false;
  if(c1.r < c2.r){
	swap(c1, c2);
	isSwapped = true;
  }
  
  double lb = 0., ub = (c2.c - c1.c).abs();
  Vector dr = (c2.c - c1.c).normalize();
  REP(it,200){
	double mid = (lb + ub) / 2.;
	c2.c = c1.c + dr * mid;
	double A = getArea(c1, c2) - AB;
	if(A >= 0){
	  lb = mid;
	}
	else
	  ub = mid;
  }
  if(isSwapped){
	swap(c1, c2);
  }
  if(abs(getArea(c1, c2) - AB) < EPS)
	return true;

  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;
}