#include <cstdio>
#include <cmath>
#include <cstring>
#include <cstdlib>
#include <climits>
#include <ctime>
#include <queue>
#include <stack>
#include <algorithm>
#include <list>
#include <vector>
#include <set>
#include <map>
#include <iostream>
#include <deque>
#include <complex>
#include <string>
#include <iomanip>
#include <sstream>
#include <bitset>
#include <valarray>
#include <iterator>
using namespace std;
typedef long long int ll;
typedef unsigned int uint;
typedef unsigned char uchar;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;

#define REP(i,x) for(int i=0;i<(int)(x);i++)
#define REPS(i,x) for(int i=1;i<=(int)(x);i++)
#define RREP(i,x) for(int i=((int)(x)-1);i>=0;i--)
#define RREPS(i,x) for(int i=((int)(x));i>0;i--)
#define FOR(i,c) for(__typeof((c).begin())i=(c).begin();i!=(c).end();i++)
#define RFOR(i,c) for(__typeof((c).rbegin())i=(c).rbegin();i!=(c).rend();i++)
#define ALL(container) (container).begin(), (container).end()
#define RALL(container) (container).rbegin(), (container).rend()
#define SZ(container) ((int)container.size())
#define mp(a,b) make_pair(a, b)
#define UNIQUE(v) v.erase( unique(v.begin(), v.end()), v.end() );

template<class T> bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T> bool chmin(T &a, const T &b) { if (a>b) { a=b; return 1; } return 0; }
template<class T> ostream& operator<<(ostream &os, const vector<T> &t) {
os<<"["; FOR(it,t) {if(it!=t.begin()) os<<","; os<<*it;} os<<"]"; return os;
}
template<class T> ostream& operator<<(ostream &os, const set<T> &t) {
os<<"{"; FOR(it,t) {if(it!=t.begin()) os<<","; os<<*it;} os<<"}"; return os;
}
template<class S, class T> ostream& operator<<(ostream &os, const pair<S,T> &t) { return os<<"("<<t.first<<","<<t.second<<")";}
template<class S, class T> pair<S,T> operator+(const pair<S,T> &s, const pair<S,T> &t){ return pair<S,T>(s.first+t.first, s.second+t.second);}
template<class S, class T> pair<S,T> operator-(const pair<S,T> &s, const pair<S,T> &t){ return pair<S,T>(s.first-t.first, s.second-t.second);}

namespace geom{
#define X real()
#define Y imag()
#define at(i) ((*this)[i])
#define SELF (*this)
	enum {TRUE = 1, FALSE = 0, BORDER = -1};
	typedef int BOOL;
	typedef double R;
	const R INF = 1e8;
	const R EPS = 1e-8;
	const R PI = 3.1415926535897932384626;
	inline int sig(const R &x) { return (abs(x) < EPS ? 0 : x > 0 ? 1 : -1); }
	inline BOOL less(const R &x, const R &y) {return sig(x-y) ? x < y : BORDER;}
	typedef complex<R> P;
	istream& operator>>(istream &is, P &p) {
		R x, y;
		is >> x >> y;
		p = P(x, y);
		return is;
	}
	inline R norm(const P &p){return p.X*p.X+p.Y*p.Y;}
	inline R inp(const P& a, const P& b){return (conj(a)*b).X;}
	inline R outp(const P& a, const P& b){return (conj(a)*b).Y;}
	inline P unit(const P& p){return p/abs(p);}
	inline P proj(const P &s, const P &t){return t*inp(s, t)/norm(t);}
	inline int ccw(const P &s, const P &t, const P &p, int adv=0){
		int res = sig(outp(t-s, p-s));
		if(res || !adv) return res;
		if(sig(inp(t-s, p-s)) < 0) return -2;	// p-s-t
		if(sig(inp(s-t, p-t)) < 0) return 2;	// s-t-p
		return 0;								// s-p-t
	}
	
	
	struct L : public vector<P>{	// line
		L(const P &p1, const P &p2){this->push_back(p1);this->push_back(p2);}
		L(){}
		P dir()const {return at(1) - at(0);}
		friend istream& operator>>(istream &is, L &l) {
			P p1, p2;
			is >> p1 >> p2;
			l = L(p1, p2);
			return is;
		}
		friend inline P proj(const P &s, const L &t){return t[0] + proj(s-t[0], t[1]-t[0]);}
		BOOL online(const P &p)const {return !sig(outp(p-at(0), dir()));}
		R dist2(const P &p)const {return norm(outp(dir(), p - at(0))) / norm(dir());}
		R dist(const P &p)const {return sqrt(dist2(p));}
	};
	struct S : public L{	// segment
		S(const P &p1, const P &p2):L(p1, p2){}
		S(){}
		BOOL online(const P &p)const {
			if(!sig(norm(p - at(0))) || !sig(norm(p - at(1)))) return BORDER;
			return !sig(abs(at(0)-p) + abs(at(1) - p) - abs(at(0) - at(1)));
		}
		R dist2(const P &p)const {
			if(inp(p-at(0),  dir()) < EPS) return norm(p - at(0));
			if(inp(p-at(1), -dir()) < EPS) return norm(p - at(1));
			return L::dist2(p);
		}
		R dist(const P &p)const {
			return sqrt(dist(p));
		}
		BOOL intersect(const S &s)const {
			const int p = ccw(at(0), at(1),  s[0], 1) * ccw(at(0), at(1),  s[1], 1);
			const int q = ccw( s[0],  s[1], at(0), 1) * ccw( s[0],  s[1], at(1), 1);
			return (p>0||q>0) ? FALSE : (!p||!q) ? BORDER : TRUE;
		}
		BOOL intersect(const L &l)const {
			if(l.online(at(0)) || l.online(at(1))) return BORDER;
			return (sig(outp(l.dir(), at(0)-l[0])) * sig(outp(l.dir(), at(1)-l[0])) <= 0);
		}
		R dist2(const L &l)const {
			if(intersect(l)) return .0;
			return min(l.dist2(at(0)), l.dist2(at(1)));
		}
		R dist2(const S &s)const {
			if(intersect(s)) return .0;
			return min(min(s.dist2(at(0)), s.dist2(at(1))), 
					   min(dist2(s[0]), dist2(s[1])));
		}
		template<class T> R dist(const T& t){return sqrt(dist2(t));}
	};
	
	struct C : public P{
		R r;
		friend istream& operator>>(istream &is, C &c) {
			operator>>(is, (P &)c);
			is >> c.r;
			return is;
		}
		BOOL inside(const P& p)const { return less(norm(p-SELF), r*r);}
	};
	inline BOOL cc_intersect(const C &a, const C &b){
		return less((a.r-b.r)*(a.r-b.r), norm(a-b)) + less(norm(a-b), (a.r+b.r)*(a.r+b.r)) - 1;
//		if(!sig(abs(a-b) - (a.r+b.r) || !sig(abs(a-b) - abs(a.r - b.r)))) return BORDER;
//		return abs(a-b)<a.r+b.r && abs(a-b)>abs(a.r - b.r);
	}
	inline int cl_intersect(const C &c, const L &l){
		return less(l.dist2(c), c.r*c.r);
	}
	inline int cs_intersect(const C &c, const S &s){
		int d = less(s.dist2(c), c.r*c.r);
		if(d != TRUE) return d;
		int p = c.inside(s[0]), q = c.inside(s[1]);
		return (p<0 || q<0) ? BORDER : p&q;
	}
	inline S cc_crosspoint(const C &c1, const C &c2){
		if(!cc_intersect(c1, c2)) return S();
		R d = abs(c1 - c2);
		R x = (c1.r*c1.r - c2.r*c2.r + d*d) / (2*d);
		R h = sqrt(c1.r*c1.r - x*x);
		P u = unit(c2-c1);
		return S(c1 + u*x + u*P(0,1)*h, c1 + u*x + u*P(0,-1)*h);
	}
	struct G : public vector<P>{
		S edge(int i)const {return S(at(i), at(i+1 == size() ? 0 : i+1));}
		BOOL contains(const P &p)const {
			R sum = .0;
			REP(i, size()){
				if(S(at(i), at((i+1)%size())).online(p)) return BORDER;	// online
				sum += arg((at(i) - p) / (at((i+1)%size()) - p));
			}
			return !!sig(sum);
		}
		BOOL contains(const S &s)const {return contains(s[0]) && contains(s[1]);}
		BOOL contains(const L &l)const {return false;}
		BOOL contains(const C &c)const {
			if(!contains((P)c)) return FALSE;
			R sum = .0;
			int res = TRUE;
			REP(i, size()){
				if(c.inside(at(i)) == TRUE || less(edge(i).dist2(c), c.r*c.r) == TRUE) return FALSE;
				else res |= c.inside(at(i)) | less(edge(i).dist2(c), c.r*c.r);
			}
			return res;
		}
		template <class T> R dist2(const T& t){
			if(contains(t)) return .0;
			R res = INF;
			REP(i, size()){
				res = min(res, edge(i).dist2(t));
			}
			return res;
		}
		template<class T> R dist(const T& t){return sqrt(dist2(t));}
		R area(){
			R sum = 0;
			REP(i, size()) sum += outp(at(i), at((i+1)%size()));
			return abs(sum / 2.);
		}
		
		G convex_hull(bool online = false){
			if(size() < 2) return *this;
			sort(ALL(*this));
			G r;
			r.resize((int)size()*2);
			int k=0;
			for(int i=0;i<size();r[k++]=at(i++))
				while(k>1 && ccw(r[k-2], r[k-1], at(i)) < 1-online) k--;
			int t = k;
			for(int i=(int)size()-1;i>=0;r[k++]=at(i--))
				while(k>t && ccw(r[k-2], r[k-1], at(i)) < 1-online) k--;
			r.resize(k-1);
			return r;
		}
	};
	inline R cc_commonarea(const C &a, const C &b){
		if(less(norm(a-b), (a.r-b.r)*(a.r-b.r)) == TRUE) return min(a.r*a.r, b.r*b.r)*PI;
		if(less((a.r+b.r)*(a.r+b.r), norm(a-b)) == TRUE) return .0;
		double d = abs(a-b);
		double rc = (d*d + a.r*a.r - b.r*b.r) / (2*d);
		double theta = acos(rc / a.r);
		double phi = acos((d - rc) / b.r);
		return a.r*a.r*theta + b.r*b.r*phi - d*a.r*sin(theta);
	}
#undef SELF
#undef at
}

using namespace geom;

namespace std{
	bool operator<(const geom::P &a, const geom::P &b) {
	    if (!geom::sig(a.X-b.X)) return (a.Y < b.Y);
	    return (a.X < b.X);
	}
}

double w, h, a, b, ab;
int main(){
	ios::sync_with_stdio(false);
	while(cin >> w >> h >> a >> b >> ab, w > 0){
		C ca, cb;
		ca.r = sqrt(a/PI);
		cb.r = sqrt(b/PI);
		if(max(ca.r, cb.r)*2 > min(w, h)){
			puts("impossible");
			continue;
		}
		int f = 0;
		if(ca.r < cb.r){
			f = 1;
			swap(ca.r, cb.r);
		}
		ca.X = ca.Y = ca.r;
		P p2(w-cb.r-ca.r, h-cb.r-ca.r);
		double l = 0, r = 1.0;
		REP(itr, 200){
			double m=(l+r)/2;
			cb.X = (ca + p2*m).X;
			cb.Y = (ca + p2*m).Y;
			if(cc_commonarea(ca, cb) < ab) r = m;
			else l = m;
		}
		if(f) swap(ca, cb);
		if(abs(cc_commonarea(ca, cb) - ab) > 1e-7) puts("impossible");
		else printf("%.9f %.9f %.9f %.9f %.9f %.9f\n", ca.X, ca.Y, ca.r, cb.X, cb.Y, cb.r);
	}
	return 0;
}

Measured memory_bytes: 1372