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>

// basis
namespace geometry {
    using real_number = double;

    constexpr real_number EPS = 1e-8;
    const real_number PI = acos(-1);
}

// point
namespace geometry {
    // using point = std::complex< real_number >;

    class point : public std::complex< real_number > {
        public:
        point() = default;

        using std::complex< real_number >::complex;

        real_number dot(const point &b) const {
            return real() * b.real() + imag() * b.imag();
        }
        real_number cross(const point &b) const {
            return real() * b.imag() - imag() * b.real();
        }
    };

    using points = std::vector< point >;
}

// line
namespace geometry { 
    class line {
        public:
        point a, b;

        line() = default;
        line(point a, point b) : a(a), b(b) {}

        line(real_number A, real_number B, real_number C) { // Ax + By = C
            if (fabs(A) < EPS) a = point(0, C / B), b = point(1, C / B);
            else if (fabs(B) < EPS) b = point(C / A, 0), b = point(C / A, 1);
            else a = point(0, C / B), b = point(C / A, 0);
        }
    };

    using lines = std::vector< line >;
}

// segment
namespace geometry {
    class segment : public line {
        segment() = default;

        using line::line;
    };

    using segments = std::vector< segment >;
}

// circle
namespace geometry {
    class circle {
        public:
        using radius = real_number;
        point p;
        radius r;

        circle(point p, radius r) : p(p), r(r) {}
    };

    using circles = std::vector< circle >;
}

namespace geometry {
    int ccw(const point &a, const point &b, const point &c) {
        const point v(b - a), w(c - a);
        if (v.cross(w) > EPS) return +1;
        if (v.cross(w) < -EPS) return -1;
        if (v.dot(w) < 0) return +2;
        if (norm(v) < norm(w)) return -2;
        return 0;
    }
}

namespace geometry {
    point projection(const line &l, const point &p) {
        real_number t = point(p - l.a).dot(point(l.a - l.b)) / norm(l.a - l.b);
        return point(l.a + (l.a - l.b) * t);
    }

    point projection(const segment &s, const point &p) {
        real_number t = point(p - s.a).dot(point(s.a - s.b)) / norm(s.a - s.b);
        return point(s.a + (s.a - s.b) * t);
    }
}

namespace geometry {
    // a-b-c
    line angle_bisector(const point &a, const point &b, const point &c) {
        const point v(a - b), w(c - b);
        const point p(v / abs(v) + w / abs(w));
        return line(b, point(p + b));
    }
}

namespace geometry {
    bool is_intersect(const segment &s, const point &p) {
        return ccw(s.a, s.b, p) == 0;
    }
}

namespace geometry {
    real_number distance(const segment &s, const point &p) {
        point r = projection(s, p);
        if (is_intersect(s, r)) return abs(r - p);
        return std::min(abs(s.a - p), abs(s.b - p));
    }

    real_number distance(const point &p1, const point &p2) {
        return abs(p1 - p2);
    }
}

namespace geometry {
    point cross_point(const line &s, const line &t) {
        real_number a = point(s.b - s.a).cross(point(t.b - t.a));
        real_number b = point(s.b - s.a).cross(point(s.b - t.a));
        if (fabs(a) < EPS && fabs(b) < EPS) return t.a;
        return point(t.a + (t.b - t.a) * b / a);
    }
}

namespace geometry {
    circle inscribed_circle(const point &a, const point &b, const point &c) {
        line s = angle_bisector(a, b, c);
        line t = angle_bisector(b, c, a);
        point x = cross_point(s, t);

        return circle(x, distance(segment(a, b), x));
    }

    circle circumscribed_circle(const point &a, const point &b, const point &c) {
        point m1((a + b) / 2.0), m2((b + c) / 2.0);
        point v((b - a).imag(), (a - b).real()), w((b - c).imag(), (c - b).real()); 
        line s(m1, point(m1 + v)), t(m2, point(m2 + w));

        point x = cross_point(s, t);
        return circle(x, distance(a, x));
    }
}

int main() {
    using namespace geometry;
    points ps(3);

    for (auto &p: ps) {
        real_number x, y;
        std::cin >> x >> y;
        p = point(x, y);
    }

    //circle c = inscribed_circle(ps[0], ps[1], ps[2]);
    circle c = circumscribed_circle(ps[0], ps[1], ps[2]);

    std::cout << std::fixed << std::setprecision(20);
    std::cout << c.p.real() << " " << c.p.imag() << " " << c.r << std::endl;
}