// diff from complex
// norm()
// absolute() 

#include<iostream>
#include<cstdio>
#include<cfloat>
#include<cassert>
#include<cmath>
#include<vector>
#include<algorithm>
#include<set>
using namespace std;

#define EPS (1e-12)
#define equals(a, b) (fabs((a) - (b)) < EPS )
#define dle(a, b) (equals(a, b) || a < b )
//#define double long double

static const double PI = acos(-1);

class Point{
    public:
    double x, y;
    
    Point ( double x = 0, double y = 0): x(x), y(y){}
    
    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 * ( double a ){ return Point(x*a, y*a); }
    Point operator / ( double a ){ return Point(x/a, y/a); }
    Point operator / ( Point p ) { return Point((x*p.x+y*p.y)/(p.x*p.x+p.y*p.y), (y*p.x-x*p.y)/(p.x*p.x+p.y*p.y)); }

    double abs() { return sqrt(norm());}
    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;
    }
};

typedef Point Vector;

class Segment{
    public:
    Point p1, p2;
  Segment(Point s = Point(), Point t = Point()): p1(s), p2(t){}

};

typedef Segment Line;

static const int CIRCLE_NON = 0;
static const int CIRCLE_OUT = 1;
static const int CIRCLE_IN = 2;
static const int CIRCLE_CROSS = 3;

class Circle{
    public:
    Point c;
    double r;
    Circle(Point c = Point(), double r = 0.0): c(c), r(r){}
};

typedef vector<Point> Polygon;

double norm( Vector a ){ return a.x*a.x + a.y*a.y; }
double abs( Vector a ){ return sqrt(norm(a)); }
Point polar( double a, double r ){ return Point(cos(r)*a, sin(r)*a);}
double getDistance( Vector a, Vector b ){ return abs(a - b); }
double dot( Vector a, Vector b ){ return a.x*b.x + a.y*b.y; }
double cross( Vector a, Vector b ){ return a.x*b.y - a.y*b.x; }
double arg(Vector p){ return atan2(p.y, p.x); }

Point project( Segment s, Point p ){
    Vector base = s.p2 - s.p1;
    double t = dot(p - s.p1, base)/norm(base);
    return s.p1 + base*t;
}

Point reflect( Segment s, Point p ){
    return p + (project(s, p) - p)*2.0;
}

bool isOnSegment( Point a, Point b, Point c){
    if ( a == c || b == c ) return true;
    return (abs(a-c) + abs(c-b) < abs(a-b) + EPS );
}

bool isOrthogonal( Vector a, Vector b ){
     return equals( dot(a, b), 0.0 );
}

bool isOrthogonal( Point a1, Point a2, Point b1, Point b2 ){
    return isOrthogonal( a1 - a2, b1 - b2 );
}

bool isOrthogonal( Segment s1, Segment s2 ){
    return equals( dot(s1.p2 - s1.p1, s2.p2 - s2.p1), 0.0 );
}

bool isParallel( Vector a, Vector b ){
    return equals( cross(a, b), 0.0 );
}

bool isParallel( Point a1, Point a2, Point b1, Point b2){
    return isParallel( a1 - a2, b1 - b2 );
}

bool isParallel( Segment s1, Segment s2 ){
    return equals( cross(s1.p2 - s1.p1, s2.p2 - s2.p1), 0.0 );
}

static const int COUNTER_CLOCKWISE = 1;
static const int CLOCKWISE = -1;
static const int ONLINE_BACK = 2;
static const int ONLINE_FRONT = -2;
static const int ON_SEGMENT = 0;

// EPS can be 0
// need to check for 920, 833, 866
int ccw( Point p0, Point p1, Point p2 ){
    Vector a = p1 - p0;
    Vector b = p2 - p0;
    if ( cross(a, b) > EPS ) return COUNTER_CLOCKWISE;
    if ( cross(a, b) < -EPS ) return CLOCKWISE;
    if ( dot(a, b) < -EPS ) return ONLINE_BACK;
    if ( norm(a) < norm(b) ) return ONLINE_FRONT;
    return ON_SEGMENT;
}

// intersect Segment p1-p2 and Segment p3-p4 ?
bool isIntersect(Point p1, Point p2, Point p3, Point p4){
    return ( ccw(p1, p2, p3) * ccw(p1, p2, p4) <= 0 &&
	     ccw(p3, p4, p1) * ccw(p3, p4, p2) <= 0 );
}

// intersect Segment s1 and Segment s2 ?
// verified by 920, 833, 866, uoa2062
bool isIntersect(Segment s1, Segment s2){
    return isIntersect(s1.p1, s1.p2, s2.p1, s2.p2);
}

// verified by 920, 833, uoa2062
Point getCrossPoint(Segment s1, Segment s2){
    assert( isIntersect(s1, s2) );
    Vector base = s2.p2 - s2.p1;
    double d1 = abs(cross(base, s1.p1 - s2.p1));
    double d2 = abs(cross(base, s1.p2 - s2.p1));
    double t = d1/(d1 + d2);
    return s1.p1 + (s1.p2 - s1.p1)*t;
}

Point getCrossPointLines( Line s1, Line s2){
    Vector a = s1.p2 - s1.p1;
    Vector base = s2.p2 - s2.p1;
    return s1.p1 + a * cross(base, s2.p1 - s1.p1)/cross(base, a);
}

// 0 <= a <= 360
double getAngleTheta(Point p){
    double polar = atan2(p.y, p.x);
    double rad = (dle(0, polar))? polar : 2*PI+polar;
    return rad*180.0/acos(-1);
}
// 0 <= a <= 2pi
double getAngle(Point p){
    double polar = atan2(p.y, p.x);
    return (dle(0, polar))? polar : 2*PI+polar;
}

// smaller angle of (a->b->c), in -pi to pi, negative when clockwise
// no in a line
double getAngle(Point a, Point b, Point c){
    return arg((a-b)/(c-b));
}

int isIntersect(Circle c1, Circle c2){
    double d = abs(c1.c - c2.c);
    if ( c1.r + c2.r < d ) return CIRCLE_NON; // no overlap
    if ( d + c2.r < c1.r ) return CIRCLE_IN;  // c1 includes c2
    if ( d + c1.r < c2.r ) return CIRCLE_OUT;  // c2 includes c1
    return CIRCLE_CROSS;
}

double getDistanceLP(Line s, Point p){ 
    return abs(cross(s.p2 - s.p1, p - s.p1)/abs(s.p2 - s.p1));
}

// 10514
double getDistance(Segment s, Point p){
    if ( dot(s.p2 - s.p1, p - s.p1) < 0.0 ) return abs(p - s.p1);
    if ( dot(s.p1 - s.p2, p - s.p2) < 0.0 ) return abs(p - s.p2);
    return abs(cross(s.p2 - s.p1, p - s.p1)/abs(s.p2 - s.p1));
}
double getDistance(Segment s1, Segment s2){
    if ( isIntersect(s1, s2) ) return 0.0;
    return min( min(getDistance(s1, s2.p1), getDistance(s1, s2.p2)),
		min(getDistance(s2, s1.p1), getDistance(s2, s1.p2)));
}

pair<Point, Point> getCrossPoints(Circle c1, Circle c2){
  assert( !(c1.c == c2.c) );
    assert( isIntersect( c1, c2 ) );
    double d = abs(c1.c - c2.c);
    double a = acos((c1.r*c1.r+d*d-c2.r*c2.r)/(2*c1.r*d));
    double t = arg(c2.c - c1.c);
    return make_pair(c1.c+polar(c1.r, t+a), c1.c+polar(c1.r, t-a));
}

bool isIntersect( Circle c1, Line l ){
    double d = getDistanceLP(l, c1.c);
    return ( equals(d, c1.r) || d < c1.r );
}

pair<Point, Point> getCrossPoints(Circle c, Line l ){
    assert( isIntersect( c, l ) );
    Vector pr = project(l, c.c);
    Vector e = (l.p2 - l.p1)/abs(l.p2 - l.p1);
    double base = sqrt(c.r*c.r - norm(pr-c.c));
    return make_pair(pr + e*base, pr - e*base);
}

Polygon cutPolygon( Polygon P, Line l ){
    Polygon u;
    for ( int i = 0; i < P.size(); i++ ){
	Point a = P[i], b = P[(i+1)%P.size()];
	if ( ccw(l.p1, l.p2, a) != CLOCKWISE ) u.push_back(a);
	if ( ccw(l.p1, l.p2, a) * ccw(l.p1, l.p2, b) == -1 ){
	    u.push_back(getCrossPointLines(Segment(a, b), l));
	}
    }
    return u;
}

bool yxCmp( const Point &p1, const Point &p2 ) {
    return (p1.y == p2.y) ? p1.x < p2.x : p1.y < p2.y;
}

class PolarAngleCmp{
    public:
    Point o;
    PolarAngleCmp( Point o): o(o){}
    bool operator()( const Point &p1,  const Point &p2) const {
	Vector a = Vector(p1.x-o.x, p1.y-o.y); // p1 - o
	Vector b = Vector(p2.x-o.x, p2.y-o.y); // p2 - o
	double c = cross(a, b);
	if ( fabs(c) < EPS ) return abs(a) < abs(b);
	return c > 0;
    }
};

// AOJ 1298
Polygon grahamScan( Polygon s ){
 if ( s.size() < 3 ) return s;
    Polygon h;
    Point lm = *min_element(s.begin(), s.end(), yxCmp);
    sort(s.begin(), s.end(), PolarAngleCmp(lm));

    for ( int i = 0; i <= 2; i++ ) h.push_back(s[i]);
    for ( int i = 3; i < s.size(); i++ ){
	while( h.size() >= 2 && ccw(h[h.size()-2], h.back(), s[i]) != COUNTER_CLOCKWISE )
	    h.pop_back();
	h.push_back(s[i]);
    }
    return h;
}
// AOJ 1298
Polygon andrewScan( Polygon s ){
    Polygon u, l;
    if ( s.size() < 3 ) return s;
    sort(s.begin(), s.end());
    u.push_back(s[0]);
    u.push_back(s[1]);
    l.push_back(s[s.size()-1]);
    l.push_back(s[s.size()-2]);
    int n;
    for ( int i = 2; i < s.size(); i++ ){
	for ( int n = u.size(); n >= 2 && ccw(u[n-2], u[n-1], s[i]) != CLOCKWISE; n--){
	    u.pop_back();
	}
	u.push_back(s[i]);
    }

    for ( int i = s.size()-3; i >= 0; i-- ){
	for ( int n = l.size(); n >= 2 && ccw(l[n-2], l[n-1], s[i]) != CLOCKWISE; n--){
	    l.pop_back();
	}
	l.push_back(s[i]);
    }
    reverse(l.begin(), l.end());
    for ( int i = u.size()-2; i >= 1; i-- ) l.push_back(u[i]);
    return l;
}

/*
 * Area of Triangle
 * if area < 0 --> ClockWise
 * else if --> Anti- ClockWise
 * Solved 10112
 */
double getArea(Point p1, Point p2, Point p3){
  return abs(0.5 * ((p3.y-p1.y)*(p2.x-p1.x)-(p2.y-p1.y)*(p3.x-p1.x)));
}
/**
 * Area of polygon
 * if area < 0 --> ClockWise
 * else if --> Anti- ClockWise
 * Solved 10406 need veri
 */
double getArea(Polygon p){
    double sum = 0.0;
    for(int i = 0; i < p.size(); i++){
	sum += cross(p[i], p[(i+1)%p.size()]);
    }
    return abs(sum/2);
}


// verified 1283
Segment shift(Segment s, double d ){
    Vector v = polar(d, arg(s.p2 - s.p1)+PI/2 );
    Segment m = Segment(s.p1 + v, s.p2 + v );
    return m;
}

// it does not work if p is on edges of pol
bool isInside(Polygon g, Point p){
  int n = g.size();
  double a = 0.0;
  for ( int i = 0; i < n; i++ ){
    if ( isOnSegment(g[i], g[(i+1)%n], p) ) return true;
    a += getAngle(g[i], p, g[(i+1)%g.size()]);
  }
  return equals(fabs(a), 2*PI);
}

/*
 IN 2
 ON 1
 OUT 0
 */
int contains(Polygon g, Point p){
  int n = g.size();
  bool x = false;
  for ( int i = 0; i < n; i++ ){
    Point a = g[i] - p, b = g[(i+1)%n] - p;
    if ( a.y > b.y ) swap(a, b);
    if ( a.y < EPS && EPS < b.y && cross(a, b) > EPS ) x = !x;
    if ( abs(cross(a, b)) < EPS && dot(a, b) < EPS ) return 1;
  }
  return (x?2:0);
}

void check( int a ){
  assert( -10000 <= a && a <= 10000);
}


#define BOTTOM 0
#define LEFT 1
#define RIGHT 2
#define TOP 3

class EndPoint{
public:
  Point p;
  int seg;
  int st;
  EndPoint(){}
  EndPoint(Point p, int seg, int st):p(p), seg(seg), st(st){}

  bool operator < ( const EndPoint &ep ) const{
    if ( p.y == ep.p.y ){
      return st < ep.st;
    } else return p.y < ep.p.y;
  }
};

int getNumOfCommonTangentLines(Circle c1, Circle c2){
  Point base = c2.c - c1.c;
  double l = abs(base);
  int cnt = 0;
  if ( abs(c1.r - c2.r) < l  ){
    cnt += 2;
    if ( c1.r + c2.r < l ){
      cnt += 2;
    }
  }
  if ( (equals(l, abs(c1.r - c2.r)) || equals(c1.r + c2.r, l) ) && !equals(l, 0) ) {
    cnt++;
  }
  return cnt;
}

double getCommonArea(Circle c2, Circle c1){
  int numc = getNumOfCommonTangentLines(c1, c2);
  // それらが離れている場合（共通接線の数が 4 の場合）4
  // それらが外接する場合（共通接線の数が 3 の場合）3
  // それらが交わる場合（共通接線の数が 2 の場合）2
  // それらが内接する場合（共通接線の数が 1 の場合）1
  // 一方がもう一方を内包する場合（共通接線がない場合）0
  if ( numc == 4 || numc == 3 ) return 0;
  if ( numc == 1 || numc == 0) return min(acos(-1)*c1.r*c1.r, acos(-1)*c2.r*c2.r);

  double ans = 0;
  double d = abs(c1.c - c2.c);
  for ( int i = 0; i < 2; i++ ){
    {
      double th = abs( acosl((c1.r*c1.r+d*d-c2.r*c2.r)/(2*c1.r*d)));
      if ( th < acos(-1)/2 ){
	ans += c1.r*c1.r*th - abs(sinl(2*th)*c1.r* c1.r/2);
      } else {
	ans += c1.r*c1.r*th + abs(sinl(2*th)*c1.r* c1.r/2);
      }
    }
    swap(c1, c2);
  }
  return ans;
}

Circle getIncircle(Point pa, Point pb, Point pc){
  Vector v1 = pb - pa;
  Vector v2 = pc - pa;
  Vector v3 = pc - pb;
  Vector v4 = pa - pb;
  Vector c1 = polar(10000.0, (arg(v1) + arg(v2))/2);
  Vector c2 = polar(10000.0, (arg(v3) + arg(v4))/2);
  Point x = getCrossPointLines(Segment(pa, pa + c1), Segment(pb, pb + c2));
  double r = getDistanceLP(Segment(pa, pb), x);
  return Circle(x, r);
}

Circle getIncircleByFormulas(Point pa, Point pb, Point pc){
  double a =  abs(pc - pb);
  double b =  abs(pc - pa);
  double c =  abs(pa - pb);
  double cx = (a*pa.x + b*pb.x + c*pc.x)/(a + b + c);
  double cy = (a*pa.y + b*pb.y + c*pc.y)/(a + b + c);
  double s = (a + b + c )/2;
  double r = sqrtl(s*(s - a)*(s - b)*(s - c))/s;
  return Circle(Point(cx, cy), r);
}

Circle getExcircle(Point pa, Point pb, Point pc){
  Vector v1 = (pb - pa);
  Vector v2 = (pc - pa);
  Vector v1r = Vector(-v1.y, v1.x);
  Vector v2r = Vector(-v2.y, v2.x);
  Point c1 = pa + v1/2;
  Point c2 = pa + v2/2;
  Point x = getCrossPointLines(Segment(c1, c1 + v1r), Segment(c2, c2 + v2r));
  double r = getDistance(pa, x);
  return Circle(x, r);
}

Circle getExcircleByFormulas(Point pa, Point pb, Point pc){
  double a =  abs(pc - pb);
  double b =  abs(pc - pa);
  double c =  abs(pa - pb);
  double x1 = pa.x;
  double y1 = pa.y;
  double x2 = pb.x;
  double y2 = pb.y;
  double x3 = pc.x;
  double y3 = pc.y;
  Point u;
  u.x = ((y1-y3)*(y1*y1 -y2*y2 +x1*x1 -x2*x2) -(y1-y2)*(y1*y1 -y3*y3 +x1*x1 -x3*x3)) / (2*(y1-y3)*(x1-x2)-2*(y1-y2)*(x1-x3));
  u.y = ((x1-x3)*(x1*x1 -x2*x2 +y1*y1 -y2*y2) -(x1-x2)*(x1*x1 -x3*x3 +y1*y1 -y3*y3)) / (2*(x1-x3)*(y1-y2)-2*(x1-x2)*(y1-y3));
  //  double r = a*b*c/sqrtl((a + b + c)*(-a + b + c)*(a - b + c)*(a + b -c));
  double r = getDistance(u, pa);
  return Circle(u, r);
}


int main(){
  double xa, ya, xb, yb, xc, yc;
  cin >> xa >> ya >> xb >> yb >> xc >> yc;
  Point pa = Point(xa, ya);
  Point pb = Point(xb, yb);
  Point pc = Point(xc, yc);

  {
    Circle cf = getIncircleByFormulas(pa, pb, pc);
    Circle c = getIncircle(pa, pb, pc);
    //    printf("%.20Lf %.20Lf %.20Lf\n", cf.c.x, cf.c.y, cf.r); // higher
    printf("%.12lf %.12lf %.12lf\n", c.c.x, c.c.y, c.r);
  }
  {
    Circle cf = getExcircleByFormulas(pa, pb, pc);
    Circle c = getExcircle(pa, pb, pc);
    //    printf("%.20Lf %.20Lf %.20Lf\n", cf.c.x, cf.c.y, cf.r);
    //    printf("%.20Lf %.20Lf %.20Lf\n", c.c.x, c.c.y, c.r); // higher
  }
  
  return 0;
}


Measured memory_bytes: 3740