// Arup Guha
// Started on 11/6/2010 at SE Regional, finished 12/21/2010
// Solution to 2010 South East Regional Problem: Equal Angles

import java.util.*;

// Manages a Point and also a Vector.
class point {
	public double x;
	public double y;
	
	public point(double myx, double myy) {
		x = myx;
		y = myy;	
	}
	
	public double distance(point p) {
		return Math.sqrt(Math.pow(x-p.x,2)+Math.pow(y-p.y,2));
	}	
		
	public double magnitude() {
		return Math.sqrt(x*x+y*y);
	}
		
	// Treat this object and other like vectors, we're finding the angle between the two.
	public double getAngle(point other) {
		return Math.acos((x*other.x+y*other.y)/(magnitude()*other.magnitude()));
	}
	
	public point getDir(point dest) {
		return new point(dest.x-x, dest.y-y);
	}
	
	public String toString() {
		return "("+x+","+y+")";
	}
}

class triangle {
	
	public point A;
	public point B;
	public point C;
	public double angleA;
	public double angleB;
	public double angleC;
	public point dirAB;
	public point dirAC;
	public point dirBA;
	public point dirBC;
	public point dirCA;
	public point dirCB;
	
	// Calculates all the necessary information about a triangle for this problem.
	public triangle(point one, point two, point three) {
		A = one;
		B = two;
		C = three;
		
		dirAB = A.getDir(B);
		dirAC = A.getDir(C);
		dirBC = B.getDir(C);
		dirBA = B.getDir(A);
		dirCA = C.getDir(A);
		dirCB = C.getDir(B);
		
		angleA = dirAB.getAngle(dirAC);
		angleB = dirBC.getAngle(dirBA);
		angleC = Math.PI - angleA - angleB;
	}
	
	// Returns 1 if angle is too big, -1 if angle is too small, 0 if it works!
	public int tryP(double angle) {
		
		// Create the lines AP and BP for the given angle.
		double refAngle = getAngleToPoint(dirAB, dirAC, angle);
		line AP = new line(A, new point(Math.cos(refAngle), Math.sin(refAngle)));
			
		double otherRefAngle = getAngleToPoint(dirBC, dirBA, angle);
		line BP = new line(B, new point(Math.cos(otherRefAngle), Math.sin(otherRefAngle)));
		
		// Calculate the point of intersection, P.
		point P = AP.intersect(BP);
		
		// Test the angle formed by PCA.
		point dirCP = C.getDir(P);
		double anglePCA = dirCP.getAngle(dirCA);
		
		// See how close it is to the original angle, which it's supposed to match.
		if (anglePCA - angle > 1e-9)
			return -1;
		else if (angle - anglePCA > 1e-9)
			return 1;
			
		return 0; // We got a match!
	}
	
	// Returns 1 if angle is too big, -1 if angle is too small, 0 if it works!
	public int tryQ(double angle) {
		
		// Create the lines AQ and BQ for the given angle.
		double refAngle = getAngleToPoint(dirAC, dirAB, angle);
		line AQ = new line(A, new point(Math.cos(refAngle), Math.sin(refAngle)));
			
		double otherRefAngle = getAngleToPoint(dirBA, dirBC, angle);
		line BQ = new line(B, new point(Math.cos(otherRefAngle), Math.sin(otherRefAngle)));
		
		// Calculate the point of intersection, Q.
		point Q = AQ.intersect(BQ);
		
		// Test the angle formed by QCB.
		point dirCQ = C.getDir(Q);
		double angleQCB = dirCQ.getAngle(dirCB);
		
		// See how close it is to the original angle, which it's supposed to match.
		if (angleQCB - angle > 1e-9)
			return -1;
		else if (angle - angleQCB > 1e-9)
			return 1;
			
		return 0; // We got a match!
	}
	
	// Just returns the point P for this triangle given angle, based on pts A and B.
	public point retP(double angle) {
		double refAngle = getAngleToPoint(dirAB, dirAC, angle);
		line AP = new line(A, new point(Math.cos(refAngle), Math.sin(refAngle)));
			
		double otherRefAngle = getAngleToPoint(dirBC, dirBA, angle);
		line BP = new line(B, new point(Math.cos(otherRefAngle), Math.sin(otherRefAngle)));
		
		point P = AP.intersect(BP);
		return P;		
	}
	
	// Just returns the point Q for this triangle given angle, based on pts A and B.
	public point retQ(double angle) {
		double refAngle = getAngleToPoint(dirAC, dirAB, angle);
		line AQ = new line(A, new point(Math.cos(refAngle), Math.sin(refAngle)));
			
		double otherRefAngle = getAngleToPoint(dirBA, dirBC, angle);
		line BQ = new line(B, new point(Math.cos(otherRefAngle), Math.sin(otherRefAngle)));
		
		point Q = AQ.intersect(BQ);
		return Q;		
	}
	
	// Obtain the point P via a binary search of angles.
	public point getP() {
		
		// Set the lowest and highest possible value for our angle.
		double low = 0;
		double high =  Math.min(angleA, angleB);
		
		double tryangle = (low+high)/2;
		int ans = tryP(tryangle);
		
		// Keep on searching until we find a match.
		while (ans != 0) {
			
			point tmp = retP(tryangle);
			
			// Based on our answer from trying the point, reset high or low.
			if (ans == 1)
				high = tryangle;
			else
				low = tryangle;
				
			// Try again!
			tryangle = (low+high)/2;	
			ans = tryP(tryangle);
		}
		
		// This is the point we want!
		return retP(tryangle);
	}
	
	// Obtain the point Q via a binary search of angles.
	public point getQ() {
		
		// Set the lowest and highest possible value for our angle.
		double low = 0;
		double high =  Math.min(angleA, angleB);
		
		double tryangle = (low+high)/2;
		int ans = tryQ(tryangle);

		// Keep on searching until we find a match.
		while (ans != 0) {
			
			point tmp = retQ(tryangle);
			
			// Based on our answer from trying the point, reset high or low.
			if (ans == 1)
				high = tryangle;
			else
				low = tryangle;
				
			tryangle = (low+high)/2;	
			ans = tryQ(tryangle);
		}
		
		// This is what we want.
		return retQ(tryangle);
	}
	
	// Maps angle in between 0 and 2PI. Works so long as angle is already in between -2PI and 2PI.
	public static double map(double angle) {
	
		if (angle < 0)
			angle += (2*Math.PI);
		return angle;
	}
	
	// Returns the directions in between startdir and enddir that is offset by angle.
	public static double getAngleToPoint(point startdir, point enddir, double angle) {
		
		// Get both of these angles.
		double angle12 = map(Math.atan2(startdir.y, startdir.x));
		double angle13 = map(Math.atan2(enddir.y, enddir.x));
		
		double refAngle;
		
		// Lots of tricky cases here, just trying to see whether angle12 or angle13
		// is bigger and also which direction is the acute angle between the two.
		// Basically we either have to subtract or add angle to angle12.
		
		if (angle12 > angle13 && angle12 - angle13 < Math.PI)	
			refAngle = angle12 - angle;
		else if (angle13 > angle12 && angle13 - angle12 < Math.PI)
			refAngle = angle12 + angle;
		else if (angle12 > angle13 && angle12 - angle13 > Math.PI)
			refAngle = (angle12 + angle)%(2*Math.PI);
		else
			refAngle = (angle12 - angle + 2*Math.PI)%(2*Math.PI);
			
		return refAngle;
	}
	
	
}

// Set up to find the intersection of two lines.
class line {
	
	public point start; // In vector equation form.
	public point dir;
	
	public line(point a, point mydir) {
		start = a;
		dir = mydir;
	}
	
	// Note: We assume the intersection exists.
	public point intersect(line other) {
		
		double top = det(other.start.x-start.x, -other.dir.x, other.start.y-start.y, -other.dir.y);
		double bot = det(dir.x, -other.dir.x, dir.y, -other.dir.y);
		
		double lambda = top/bot;
		
		return new point(start.x+lambda*dir.x, start.y+lambda*dir.y);
		
	}
	
	public static double det(double a, double b, double c, double d) {
		return a*d - b*c;
	}
}

public class d {
	
	public static void main(String[] args) {
		
		
		Scanner stdin = new Scanner(System.in);
		
		int ax, ay, bx, by, cx, cy;
		
		// Get the points.
		ax = stdin.nextInt();
		ay = stdin.nextInt();
		bx = stdin.nextInt();
		by = stdin.nextInt();
		cx = stdin.nextInt();
		cy = stdin.nextInt();
		
		// Go through each case.
		while (ax != 0 || ay != 0 || bx != 0 || by != 0 || cx != 0 || cy != 0) {
			
			point a = new point(ax, ay);
			point b = new point(bx, by);
			point c = new point(cx, cy);
			triangle mine = new triangle(a,b,c);
			
			// Get our answers and print them.
			point P = mine.getP();
			point Q = mine.getQ();
			System.out.printf("%.2f %.2f %.2f %.2f\n",P.x, P.y, Q.x, Q.y);
			
			// Get the next triangle.
			ax = stdin.nextInt();
			ay = stdin.nextInt();
			bx = stdin.nextInt();
			by = stdin.nextInt();
			cx = stdin.nextInt();
			cy = stdin.nextInt();
		}
	}
	
}