/*
 * Origami Beloch Fold - Fred Pickel
 * Greater NY Regional
 */
#include <stdio.h>
#include <stdlib.h>
#include <math.h>


#define EPS (1.0e-6)
#define DEPS (.01)
#define DMAGEPS (1.0e-10)
#define MAX_N	1000
#define MAX_FACT	(1.0e8)

double px, py, ma, mb, mc, qx, qy, na, nb, nc;
double mx0, my0, nx0, ny0;	// points on m, n

double ka, kb, kc;	// fold line
double kt;	// signed distance along line M from (mx0,my0)
double kx, ky;	// pt on fold line
double scale;

int Normalize()
{
	double d;
	d = ma*px + mb*py + mc;
	if(fabs(d) < EPS) {	// P on M
		return -1;
	}
	d = na*qx + nb*qy + nc;
	if(fabs(d) < EPS) {	// Q on N
		return -1;
	}

	d = fabs(px - qx) + fabs(py - qy);
	if(d < EPS) {	// P == Q
		return -4;
	}

	d = ma*ma + mb *mb;	// invalid M
	if(fabs(d) < EPS) {
		return -2;
	}
	d = 1.0/sqrt(d);
	ma *= d; mb *= d; mc *= d;
	d = px*ma + py*mb + mc;
	mx0 = px - d*ma;
	my0 = py - d*mb;
	scale = fabs(mx0);
	if(scale < fabs(my0)) scale = fabs(my0);

	d = na*na + nb *nb;
	if(fabs(d) < EPS) {	// invalid N
		return -2;
	}
	d = 1.0/sqrt(d);
	na *= d; nb *= d; nc *= d;
	d = qx*na + qy*nb + nc;
	nx0 = qx - d*na;
	ny0 = qy - d*nb;
	if(scale < fabs(nx0)) scale = fabs(nx0);
	if(scale < fabs(ny0)) scale = fabs(ny0);
	
	d = ma*nb - na*mb;
	if(fabs(d) < EPS) {	// M || N
		return -3;
	}
	if(scale < fabs(px)) scale = fabs(px);
	if(scale < fabs(py)) scale = fabs(py);
	if(scale < fabs(qx)) scale = fabs(qx);
	if(scale < fabs(qy)) scale = fabs(qy);

	return 0;
}

// normalize k, compute reflections of P, Q in K and plug into M and N equations
double FoldErr(double t)
{
	double px1, py1, qx1, qy1, dot, kdot, ret;
	px1 = mx0 - t*mb;
	py1 = my0 + t*ma;
	ka = px - px1;
	kb = py - py1;
	kc = -0.5*(ka*(px + px1) + kb*(py + py1));

	kdot = ka*ka + kb*kb;
	dot = (qx)*ka + (qy)*kb + kc;
	qx1 = qx - 2.0*dot*ka/kdot;
	qy1 = qy - 2.0*dot*kb/kdot;
	ret = na*qx1 + nb*qy1 + nc;
	return ret;
}

// errlft*errt <0.0
int IntervalSearch(double lft, double rt, double errlft, double errrt)
{
	double left, right, cen, err, lefterr, righterr, dedt;
	int cnt = 0;
	lefterr = errlft;
	righterr = errrt;
	left = lft;
	right = rt;
	cen = 0.5*(lft + rt);
	err = FoldErr(cen);
	while((cnt < 20) && (fabs(err) >= EPS)) {
		if(err*lefterr > 0.0) {
			lefterr = err;
			left = cen;
		} else {
			righterr = err;
			right = cen;
		}
		dedt = (FoldErr(cen + DEPS) - err)/DEPS;
		// try newton
		if((fabs(dedt) < EPS) ||((cen = cen - err/dedt) <= left) || (cen >= right)) {	// if outside the interval, use center
			cen = (0.5*(left + right));
		}
		err = FoldErr(cen);
	}
	if(fabs(err) >= EPS) {
		return -1;
	}
	return 0;
}

int FindFold()
{
	double errlft, errrt, errcen;
	errcen = FoldErr(0.0);
	if(fabs(errcen) < EPS){
		return 0;
	}
	errlft = FoldErr(-MAX_FACT * scale);
	if(fabs(errlft) < EPS){
		return 0;
	}
	errrt = FoldErr(MAX_FACT * scale);
	if(fabs(errrt) < EPS){
		return 0;
	}
	if(errlft*errcen < 0.0) {
		IntervalSearch(-MAX_FACT * scale, 0.0, errlft, errcen);
		return 0;
	} else if(errrt*errcen < 0.0) {
		IntervalSearch(0.0, MAX_FACT * scale, errcen, errrt);
		return 0;
	}
	return -1;
}

char inbuf[255];

int main()
{ 
	if(scanf("%lf %lf %lf %lf %lf %lf %lf %lf %lf %lf",
		&px, &py, &ma, &mb, &mc, &qx, &qy, &na, &nb, &nc) != 10){
		fprintf(stderr, "scan failed on input data\n");
		return -4;
	}
	if(Normalize() != 0) {
		fprintf(stderr, "invalid input - normalize?\n");
		return -6;
	}
	if(FindFold() == 0) {
		printf("%0.4lf %0.4lf %0.4lf\n", ka, kb, kc);
	} else {
		fprintf(stderr, "FindFold ret != 0\n");
	}
	return 0;

}