#include <bits/stdc++.h>

#define _overload(_1,_2,_3,name,...) name
#define _rep(i,n) _range(i,0,n)
#define _range(i,a,b) for(int i=int(a);i<int(b);++i)
#define rep(...) _overload(__VA_ARGS__,_range,_rep,)(__VA_ARGS__)

#define _rrep(i,n) _rrange(i,n,0)
#define _rrange(i,a,b) for(int i=int(a)-1;i>=int(b);--i)
#define rrep(...) _overload(__VA_ARGS__,_rrange,_rrep,)(__VA_ARGS__)

#define _all(arg) begin(arg),end(arg)
#define uniq(arg) sort(_all(arg)),(arg).erase(unique(_all(arg)),end(arg))
#define getidx(ary,key) lower_bound(_all(arg),key)-begin(arg)
#define clr(a,b) memset((a),(b),sizeof(a))
#define bit(n) (1LL<<(n))

using namespace std;

template<class T>void reg(vector<T> &ary,const T &elem){ary.emplace_back(elem);}
template<class T>bool chmin(T &a, const T &b) {return (b<a)?(a=b,1):0;}
template<class T>bool chmax(T &a, const T &b) { return (a<b)?(a=b,1):0;}

using R=long double; // __float128
const R EPS = 1E-10; // [-1000:1000]->EPS=1e-8 [-10000:10000]->EPS=1e-7
const R EPS2 = 1E-4; // [-1000:1000]->EPS=1e-8 [-10000:10000]->EPS=1e-7
const R INF = 1E40;
constexpr R PI = acos(R(-1));
inline int sgn(const R& r){ return (r > EPS) - (r < -EPS);}
inline int sgn(const R& a, const R &b){ return sgn(a-b); }
inline R sq(R x){return sqrt(max<R>(x,0.0));}

using P=complex<R>;
using C=struct{P c;R r;};
ostream& operator << (ostream& os,P& p){ os << real(p) << " " << imag(p); return os;}

enum RCC{IN=1,ON_IN=2,ISC=4,ON_OUT=8,OUT=16,ONS=10};
int rcc(C a,C b){
	R d=abs(a.c-b.c);
	if(sgn(a.r+b.r-d)<0) return OUT;
	if(sgn(a.r+b.r-d)==0) return ON_OUT;
	if(sgn(abs(a.r-b.r)-d)<0) return ISC;
	if(sgn(abs(a.r-b.r)-d)==0) return ON_IN;
	return IN;
}

R area(C c1,C c2){
	R d=abs(c2.c-c1.c);
   	int r=rcc(c1,c2);
    if(r>=ON_OUT) return 0.0;  
    if(r==IN) return min(norm(c1.r),norm(c2.r))+PI;
    R rc=(norm(d)+ norm(c1.r) - norm(c2.r))/(2.0*d),theta=acos(rc/c1.r),phi=acos((d-rc)/c2.r);
    return norm(c1.r)*theta+norm(c2.r)*phi-d*c1.r*sin(theta);
}

C calc(C c1,C c2,R s){
	C ok=C({c1.c,c2.r}),ng=c2;
	rep(loop,200){
		const C mid=C({(ok.c+ng.c)/P(2,0),c2.r});
		R res=area(c1,mid);
		if(res<=s)
			ok=mid;
		else
			ng=mid;
	}
	return ok;
}

int main(void){
	int w,h,a,b,c;
	while(cin >> w >> h >> a >> b >> c,w){
		R ra=sq(1.0*a/PI),rb=sq(1.0*b/PI);
		bool ok=true;
		if(min(w,h)<2*max(ra,rb)) ok=false;
		C c1={P(ra,ra),ra},c2={P(w-rb,h-rb),rb};
		R limit=area(c1,c2);
		if(c<limit) ok=false;
		if(ok){
			cout.precision(20);
			if(c1.r>c2.r)
				c2=calc(c1,c2,c);
			else
				c1=calc(c2,c1,c);
			cout << fixed << c1.c << " " << c1.r << " " << c2.c  << " " << c2.r << endl;
		}else{
			cout << "impossible" << endl;
		}
	}
	return 0;
}