#include <iostream>
#include <iomanip>
#include <complex>
#include <vector>
#include <algorithm>
#include <cmath>
using namespace std;
const double EPS = 1e-8;
const double INF = 1e12;
const double PI = acos(-1);
#define EQ(n,m) (abs((n)-(m)) < EPS)
#define X real()
#define Y imag()

typedef complex<double> P;
typedef vector<P> VP;
struct C{
    P p;
    double r;
    C(const P& p, const double& r) : p(p), r(r) {}
    C(){}
};

P unit(const P &p){
    return p/abs(p);
}
double commonareaCC(C a, C b){
    if(a.r < b.r) swap(a,b);
    double d = abs(b.p-a.p);
    if(d +EPS > a.r+b.r){
        return 0;
    }
    if(d < a.r-b.r +EPS){
        return PI *b.r *b.r;
    }
    double arg_a = 2 *acos((a.r*a.r +d*d -b.r*b.r)/(2*a.r*d));
    double arg_b = 2 *acos((b.r*b.r +d*d -a.r*a.r)/(2*b.r*d));
    double poly = a.r*a.r*sin(arg_a)/2 +b.r*b.r*sin(arg_b)/2;
    double sector = a.r*a.r*arg_a/2 +b.r*b.r*arg_b/2;
    return sector -poly;
}

int main(){
    while(1){
        double w,h,itssize;
        double size[2];
        cin >> w >> h >> size[0] >> size[1] >> itssize;
        if(w == 0) break;

        C c[2];
        bool ng = false;
        for(int d=0; d<2; d++){
            c[d].r = sqrt(size[d] /PI);
            if(2*c[d].r > min(w, h) +EPS){
                ng = true;
            }
        }
        if(c[0].r < c[1].r){
            c[1].p = P(c[1].r, c[1].r);
            c[0].p = P(w-c[0].r, h-c[0].r);
        }else{
            c[0].p = P(c[0].r, c[0].r);
            c[1].p = P(w-c[1].r, h-c[1].r);
        }
        if(commonareaCC(c[0], c[1]) > itssize +EPS){
            ng = true;
        }

        if(ng){
            cout << "impossible" << endl;
            continue;
        }

        double lb=0, ub=abs(c[0].p -c[1].p);
        for(int rep=0; rep<50; rep++){
            double mid = (lb + ub)/2.0;
            C tmpc[2] = {C(P(0, 0), c[0].r), C(P(mid, 0), c[1].r)};
            if(commonareaCC(tmpc[0], tmpc[1]) >= itssize){
                lb = mid;
            }else{
                ub = mid;
            }
        }
        if(c[0].r < c[1].r){
            c[0].p = c[1].p +unit(c[0].p -c[1].p) *lb;
        }else{
            c[1].p = c[0].p +unit(c[1].p -c[0].p) *lb;
        }

        cout << fixed << setprecision(9);
        cout << c[0].p.X << " " << c[0].p.Y << " " << c[0].r << " ";
        cout << c[1].p.X << " " << c[1].p.Y << " " << c[1].r << endl;
    }
    return 0;
}
