// Arup Guha
// 12/24/2015
// Solution to UCF 1987 HS Contest Problem: Circular Reasoning

// Note: The posted data is incorrect. The last case is set up to have the following center: (-33.125, 38.125) if you work it
//       out by hand exactly. Rounded, this is -33.13 and 38.13, which is what my program prints out. My guess is that precision
//       for doubles or floats back in 1987 wasn't as good, which is why their solution prints -33.12 and 38.12.

import java.util.*;

public class circle {

	public static void main(String[] args) {

		Scanner stdin = new Scanner(System.in);
		while (stdin.hasNext()) {

			// Read in pts.
			double[] pt1 = getPt(stdin);
			double[] pt2 = getPt(stdin);
			double[] pt3 = getPt(stdin);

			// Get the two perpendicular bisectors.
			line perpBisect1 = getPerpBisect(pt1, pt2);
			line perpBisect2 = getPerpBisect(pt1, pt3);

			// Get the intersection.
			double[] center = perpBisect1.intersect(perpBisect2);

			// And radius.
			double radius = dist(center, pt1);

			// Print in their format.
			System.out.printf("Center: (%7.2f,%7.2f) Radius:%8.2f\n", center[0], center[1], radius);
		}
	}

	// Reads in a two dimensional pt from stdin and returns it.
	public static double[] getPt(Scanner stdin) {
		double[] res = new double[2];
		res[0] = stdin.nextDouble();
		res[1] = stdin.nextDouble();
		return res;
	}

	// Returns the distance between pt1 and pt2.
	public static double dist(double[] pt1, double[] pt2) {
		return Math.sqrt(Math.pow(pt1[0]-pt2[0],2) + Math.pow(pt1[1]-pt2[1],2));
	}

	public static line getPerpBisect(double[] pt1, double[] pt2) {

		// Mid point.
		double[] pt = new double[2];
		pt[0] = (pt1[0]+pt2[0])/2;
		pt[1] = (pt1[1]+pt2[1])/2;

		// Perpendicular direction.
		double[] dir = new double[2];
		dir[0] = pt2[1] - pt1[1];
		dir[1] = pt1[0] - pt2[0];

		// Here is the line.
		return new line(pt, dir);
	}


}

class line {

	public double[] pt;
	public double[] dir;

	public line(double[] mypt, double[] mydir) {
		pt = mypt;
		dir = mydir;
	}

	public double[] intersect(line other) {

		// Get denominator for Kramer's Rule.
		double den = det(dir[0], -other.dir[0], dir[1], -other.dir[1]);
		if (Math.abs(den) < 1e-9) return null;

		// Get numerator for lambda, parameter on this line.
		double num = det(other.pt[0]-pt[0], -other.dir[0], other.pt[1]-pt[1], -other.dir[1]);
		double lambda = num/den;

		// Form point and return it.
		double[] res = new double[2];
		res[0] = pt[0] + lambda*dir[0];
		res[1] = pt[1] + lambda*dir[1];
		return res;
	}

	public static double det(double a, double b, double c, double d) {
		return a*d - b*c;
	}
}