Problem: Write a program which prints the central coordinate ($cx$,$cy$) and the radius $r$ of a circumscribed circle of a triangle which is constructed by three points ($x_1$, $y_1$), ($x_2$, $y_2$) and ($x_3$, $y_3$) on the plane surface.

Constraints

* $-10000 \leq x_i, y_i \leq 10000$
* The three points are not on the same straight line

Input

The input is given in the following format


$x_1$ $y_1$
$x_2$ $y_2$
$x_3$ $y_3$


All the input are integers.

Output

Print $cx$, $cy$ and $r$ separated by a single space in a line. The output val ues should be in a decimal fraction with an error less than 0.000001.

Examples

Input

1 -2
3 2
-2 0


Output

0.62500000000000000000 0.68750000000000000000 2.71353666826155124291


Input

0 3
4 0
0 0


Output

2.00000000000000000000 1.50000000000000000000 2.50000000000000000000

Solution (in CPP):

Solution:
#include<bits/stdc++.h>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define HUGE_NUM 1000000000000000000
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;





struct Point{
	Point(long double arg_x,long double arg_y){
		x = arg_x;
		y = arg_y;
	}

	Point(){
		x = y = 0.0;
	}

	Point operator + (Point p){ return Point(x+p.x,y+p.y); }
	Point operator - (Point p){ return Point(x-p.x,y-p.y);}
	Point operator * (long double a){ return Point(a*x,a*y); }
	Point operator / (long double a){ return Point(x/a,y/a); }

	long double abs(){ return sqrt(norm()); }
	long double norm(){ return x*x + y*y; }

	bool operator<(const Point &p) const{
		return x != p.x? x < p.x: y < p.y;
	}

	bool operator == (const Point &p) const{
		return fabs(x-p.x) < EPS && fabs(y-p.y) < EPS;
	}

	long double x,y;
};

typedef Point Vector;

struct Line{
	Line(){

	}
	Line(Point a,Point b){
		p[0] = a;
		p[1] = b;
	}
	Point p[2];
};

struct Info{
	Info(Point arg_point,long double arg_slope){
		point = arg_point;
		slope = arg_slope;
	}
	bool operator<(const struct Info &arg) const{

		return slope < arg.slope;
	}

	Point point;
	long double slope;
};


long double calc_dist(Point A,Point B){

	return sqrt((A.x-B.x)*(A.x-B.x)+(A.y-B.y)*(A.y-B.y));
}


long double calc_slope(Line A){

	if(fabs(A.p[0].x-A.p[1].x) < EPS){

		return DBL_MAX;

	}else if(fabs(A.p[0].y-A.p[1].y) < EPS){

		return 0;

	}else{

		return (A.p[1].y-A.p[0].y)/(A.p[1].x-A.p[0].x);
	}
}

//交点を求める関数
Point calc_Cross_Point(long double x1,long double x2,long double x3,long double x4,long double y1,long double y2,long double y3,long double y4){
	Point ret;
	ret.x = ((x2-x1)*(y3*(x4-x3)+x3*(y3-y4))-(x4-x3)*(y1*(x2-x1)+x1*(y1-y2)))/((y2-y1)*(x4-x3)-(y4-y3)*(x2-x1));
	if(x1 != x2){
		ret.y = ((y2-y1)*ret.x+y1*(x2-x1)+x1*(y1-y2))/(x2-x1);
	}else{
		ret.y = ((y4-y3)*ret.x+y3*(x4-x3)+x3*(y3-y4))/(x4-x3);
	}
	return ret;
}

//インタフェース関数
Point calc_Cross_Point(Point a,Point b,Point c,Point d){
	return calc_Cross_Point(a.x,b.x,c.x,d.x,a.y,b.y,c.y,d.y);
}

Point calc_minus(Point a,Point b){
    Point ret;

    ret.x = a.x-b.x;
    ret.y = a.y-b.y;

    return ret;
}

int func(long double x1,long double y1,long double x2, long double y2, long double xp, long double yp){
	long double naiseki,norm1,norm2,gaiseki;
	norm1 = sqrt((x2-x1)*(x2-x1)+(y2-y1)*(y2-y1));
	norm2 = sqrt((xp-x1)*(xp-x1)+(yp-y1)*(yp-y1));
	naiseki = (xp-x1)*(x2-x1)+(yp-y1)*(y2-y1);
	gaiseki = (x2-x1)*(yp-y1)-(xp-x1)*(y2-y1);
	if(gaiseki > EPS){
		return 1;
	}else if(gaiseki < -EPS){
		return -1;
	}
	if(naiseki < -EPS){
		return 2;
	}

	if(norm1 < norm2){
		return -2;
	}
	return 0;
}


bool is_Cross(Line a,Line b){

	if(func(a.p[0].x,a.p[0].y,a.p[1].x,a.p[1].y,b.p[0].x,b.p[0].y)*
			func(a.p[0].x,a.p[0].y,a.p[1].x,a.p[1].y,b.p[1].x,b.p[1].y) <= 0 &&
			func(b.p[0].x,b.p[0].y,b.p[1].x,b.p[1].y,a.p[0].x,a.p[0].y)*
			func(b.p[0].x,b.p[0].y,b.p[1].x,b.p[1].y,a.p[1].x,a.p[1].y) <= 0){
		return true;
	}
	return false;
}

long double calc_len(Vector a){
    return sqrt(a.x*a.x+a.y*a.y);
}

long double norm(Vector a){
	return a.x*a.x+a.y*a.y;
}

long double abs(Vector a){
	return sqrt(norm(a));
}

long double cross(Vector a,Vector b){
    return a.x*b.y-a.y*b.x;
}

long double dot(Vector a,Vector b){
    return a.x*b.x + a.y*b.y;
}

//線分ではなく直線と点の距離
long double getDistanceLP(Line l,Point p){
    return fabs(cross(calc_minus(l.p[1],l.p[0]),calc_minus(p,l.p[0]))/calc_len(calc_minus(l.p[1],l.p[0])));
}

//点と線分の距離
long double getDistanceSP(Line l,Point p){
	if(dot(calc_minus(l.p[1],l.p[0]),calc_minus(p,l.p[0])) < 0.0)return calc_len(calc_minus(p,l.p[0]));
	if(dot(calc_minus(l.p[0],l.p[1]),calc_minus(p,l.p[1])) < 0.0)return calc_len(calc_minus(p,l.p[1]));
	return getDistanceLP(l,p);
}

//線分と線分の距離
long double getDistance(Line A,Line B){
	if(is_Cross(A,B))return 0.0;
	return min(min(getDistanceSP(A,B.p[0]),getDistanceSP(A,B.p[1])),
			min(getDistanceSP(B,A.p[0]),getDistanceSP(B,A.p[1])));
}

Point calc_Cross_Point(Line A,Line B){

	if(getDistanceSP(B,A.p[0]) < EPS){

		return A.p[0];

	}else if(getDistanceSP(B,A.p[1]) < EPS){

		return A.p[1];

	}else if(getDistanceSP(A,B.p[0]) < EPS){

		return B.p[0];

	}else if(getDistanceSP(A,B.p[1]) < EPS){

		return B.p[1];
	}

	return calc_Cross_Point(A.p[0],A.p[1],B.p[0],B.p[1]);
}

/*
誤差がきつ過ぎる悪問
*/

int main(){

	Point point[3];
	long double NUM = 30000000.0;

	for(int i = 0; i < 3; i++){

		scanf("%Lf %Lf",&point[i].x,&point[i].y);
	}

	//三角形の辺
	Line base_line1 = Line(point[0],point[1]);
	Line base_line2 = Line(point[1],point[2]);
	Line base_line3 = Line(point[0],point[2]);

	//中点
	Point mid1 = Point((point[0].x+point[1].x)/2,(point[0].y+point[1].y)/2);
	Point mid2 = Point((point[1].x+point[2].x)/2,(point[1].y+point[2].y)/2);
	Point mid3 = Point((point[0].x+point[2].x)/2,(point[0].y+point[2].y)/2);

	long double slope1 = calc_slope(base_line1);
	long double slope2 = calc_slope(base_line2);
	long double slope3 = calc_slope(base_line3);

	vector<Info> info;
	info.push_back(Info(mid1,slope1));
	info.push_back(Info(mid2,slope2));
	info.push_back(Info(mid3,slope3));

	//なるべく傾きが違う2つを使う
	sort(info.begin(),info.end());

	Point work1 = info[0].point,work2 = info[2].point;
	long double tmp1 = info[0].slope,tmp2 = info[2].slope;

	mid1 = work1;
	mid2 = work2;
	slope1 = tmp1;
	slope2 = tmp2;

	//垂直二等分線
	Line line1,line2;

	if(fabs(slope1-DBL_MAX) < EPS){ //垂直

		line1.p[0] = Point(-NUM,mid1.y);
		line1.p[1] = Point(NUM,mid1.y);

	}else if(fabs(slope1) < EPS){ //水平

		line1.p[0] = Point(mid1.x,NUM);
		line1.p[1] = Point(mid1.x,-NUM);

	}else{

		slope1 = (-1.0)/slope1;

		line1.p[0] = Point(mid1.x-NUM,mid1.y-NUM*slope1);
		line1.p[1] = Point(mid1.x+NUM,mid1.y+NUM*slope1);
	}

	if(fabs(slope2-DBL_MAX) < EPS){ //垂直

		line2.p[0] = Point(-NUM,mid2.y);
		line2.p[1] = Point(NUM,mid2.y);

	}else if(fabs(slope2) < EPS){ //水平

		line2.p[0] = Point(mid2.x,NUM);
		line2.p[1] = Point(mid2.x,-NUM);

	}else{

		slope2 = (-1.0)/slope2;

		line2.p[0] = Point(mid2.x-NUM,mid2.y-NUM*slope2);
		line2.p[1] = Point(mid2.x+NUM,mid2.y+NUM*slope2);
	}

	Point center =  calc_Cross_Point(line1,line2);

	long double r = calc_dist(center,point[0]);

	printf("%.10Lf %.10Lf %.10Lf\n",center.x,center.y,r);

	return 0;
}