#include <bits/stdc++.h>

#ifdef LOCAL
#include "dump.hpp"
#else
#define dump(...)
#endif

using namespace std;

constexpr double EPS = 1e-6;

struct point {
	double x, y;
	explicit point(double x_ = 0.0, double y_ = 0.0):x(x_), y(y_) {}
	point(const point &p):x(p.x), y(p.y) {}

	point operator+(const point &p) const {
		return point(x + p.x, y + p.y);
	}

	point operator-(const point &p) const {
		return point(x - p.x, y - p.y);
	}

	point operator*(double s) const {
		return point(x * s, y * s);
	}

	point operator*(const point &p) const {
		return point(x * p.x - y * p.y, x * p.y + y * p.x);
	}

	point operator/(double s) const {
		return point(x / s, y / s);
	}
};

double norm(const point &p) {
	return p.x * p.x + p.y * p.y;
}

double abs(const point &p) {
	return sqrt(norm(p));
}

double dot(const point &a, const point &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;
}

struct circle {
	point c;
	double r;
	circle(const point &c_, const double &r_):c(c_), r(r_){}
};

int ccw(const point &a, point b, point c) {
	b = b - a;
	c = c - a;
	const double tmp = cross(b, c);
	if(tmp > EPS) return 1; // ccw
	if(tmp < -EPS) return -1; // cw
	if(dot(b, c) < 0) return 2; // c, a, b 順に一直線上
	if(norm(b) < norm(c)) return -2; // a, b, c 順に一直線上
	return 0; //a, c, b 順で一直線上
}

bool intersect(const circle &c, const point &p) {
	return abs(c.c - p) + EPS < c.r;
}

bool intersect(const circle &c, const circle &d) {
	return abs(c.c - d.c) + EPS < c.r + d.r && abs(c.c - d.c) > abs(c.r - d.r) + EPS;
}

vector<point> crosspoint(const circle &c, const circle &d) {
	vector<point> res;
	if(abs(c.c - d.c) < EPS) return res; // 中心の座標が同じ

	const double tmp = abs(c.c - d.c);
	const double rc = (tmp * tmp + c.r * c.r - d.r * d.r) / (tmp + tmp);
	const double rs = sqrt(c.r * c.r - rc * rc);
	const point diff = (d.c - c.c) / tmp;
	res.emplace_back(c.c + diff * point(rc, rs));
	res.emplace_back(c.c + diff * point(rc, -rs));
	return res;
}

const string NG = "impossible";

double rad(point a, point b, const point &base = point(0, 0)) {
	a = a - base;
	b = b - base;
	const int c = ccw(point(0, 0), a, b);
	if(abs(c) != 1) return 0;
	return c * acos(dot(a, b) / (abs(a) * abs(b)));
}

double common_area(const circle &a, const circle &b) {
	if(!intersect(a, b)) return (intersect(a, b.c) || intersect(b, a.c) ? min(a.r * a.r * M_PI, b.r * b.r * M_PI) : 0.0);
	const auto cp = crosspoint(a, b);
	return a.r * a.r * abs(rad(cp.front(), b.c, a.c)) + b.r * b.r * abs(rad(cp.front(), a.c, b.c)) - abs(cross(a.c - cp.front(), b.c - cp.front()));
}

inline string solve(int w, int h, int A, int B, int A_B) {
	const int S = w * h;
	if(S <= A || S <= B) return NG;

	bool change = false;

	double ra = sqrt(A / M_PI);
	double rb = sqrt(B / M_PI);

	if(ra < rb) {
		swap(ra, rb);
		change = true;
	}

	if(min(w, h) < 2 * ra || min(w, h) < 2 * rb) return NG;

	circle a(point(ra, ra), ra);
	circle b(point(w - rb, h - rb), rb);

	if(A_B < common_area(a, b)) return NG;

	point L(ra, ra), R(w - rb, h - rb);
	for(int i = 0; i < 50; ++i) {
		const point M = (L + R) * 0.5;
		if(common_area(a, circle(M, rb)) < A_B) {
			R = M;
		}
		else {
			L = M;
		}
	}
	b.c = L;

	if(change) swap(a, b);

	ostringstream oss;
	oss.setf(ios::fixed);
	oss.precision(10);

	oss << a.c.x << ' ' << a.c.y << ' ' << a.r << ' ';
	oss << b.c.x << ' ' << b.c.y << ' ' << b.r;
	return oss.str();
}

int main() {
	cin.tie(nullptr);
	ios::sync_with_stdio(false);

	for(int w, h, A, B, A_B; cin >> w >> h >> A >> B >> A_B && w;) {
		cout << solve(w, h, A, B, A_B) << endl;
	}

	return EXIT_SUCCESS;
}

Measured memory_bytes: 1360