#include <algorithm>
#include <array>
#include <assert.h>
#include <bitset>
#include <chrono>
#include <cmath>
#include <complex>
#include <cstring>
#include <functional>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <istream>

#include <map>
#include <math.h>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>

namespace asl
{
    
    template <typename numeric_type>
    class point
    {
    public:
        numeric_type x, y;

        point(numeric_type x = 0, numeric_type y = 0) : x(x), y(y) {}

        point<numeric_type> conj() const
        {
            return point(x, -y);
        }

        point<numeric_type> &operator+=(const point<numeric_type> &ri)
        {
            x += ri.x;
            y += ri.y;
            return *this;
        }

        point<numeric_type> &operator-=(const point<numeric_type> &ri)
        {
            x -= ri.x;
            y -= ri.y;
            return *this;
        }

        point<numeric_type> &operator*=(const point<numeric_type> &ri)
        {
            auto _x = x * ri.x - y * ri.y;
            auto _y = x * ri.y + y * ri.x;
            x = _x;
            y = _y;
            return *this;
        }

        point<numeric_type> &operator/=(const numeric_type &ri)
        {
            x /= ri;
            y /= ri;
            return *this;
        }

        point<numeric_type> &operator/=(point<numeric_type> &ri)
        {
            *this *= ri.conj();
            *this /= ri.square_norm();
            return *this;
        }

        numeric_type square_norm()
        {
            return x * x + y * y;
        }

        friend point<numeric_type> operator+(const point<numeric_type> &a, const point<numeric_type> &b)
        {
            return point<numeric_type>(a) += b;
        }

        friend point<numeric_type> operator-(const point<numeric_type> &a, const point<numeric_type> &b)
        {
            return point<numeric_type>(a) -= b;
        }

        friend point<numeric_type> operator*(const point<numeric_type> &a, const point<numeric_type> &b)
        {
            return point<numeric_type>(a) *= b;
        }

        friend point<numeric_type> operator/(const point<numeric_type> &a, point<numeric_type> b)
        {
            return point<numeric_type>(a) /= b;
        }

    };

    template <typename numeric_type>
    std::ostream &operator<<(std::ostream &out, const point<numeric_type> &p)
    {
        return out << p.x << " " << p.y;
    }

    template <typename numeric_type>
    std::istream &operator>>(std::istream &is, point<numeric_type> &p)
    {
        return is >> p.x >> p.y;
    }

    template <typename numeric_type>
    numeric_type norm(const point<numeric_type> &a)
    {
        return a.x * a.x + a.y * a.y;
    }

    template <typename numeric_type>
    point<numeric_type> conj(const point<numeric_type> &a)
    {
        return a.conj();
    }

    template <typename numeric_type, typename float_type = double>
    float_type abs(const point<numeric_type> &a)
    {
        return sqrtl(norm(a));
    }

} 

#include <stdint.h>

#include <experimental/optional>

namespace asl
{
    template <typename numeric_type>
    class circle
    {
    public:
        point<numeric_type> p;
        numeric_type r;
    };

    template <typename numeric_type>
    std::ostream &operator<<(std::ostream &out, const circle<numeric_type> &c)
    {
        return out << c.p << " " << c.r;
    }

    template <typename numeric_type>
    circle<numeric_type> circumscribed_circle_triangle(const point<numeric_type> &a, const point<numeric_type> &b, const point<numeric_type> &c)
    {
        point<numeric_type> x = 1.0 / conj(b - a), y = 1.0 / conj(c - a);
        auto center = (y - x) / (conj(x) * y - x * conj(y)) + a;
        auto ratio = abs(a - center);
        return {center, ratio};
    }

} 

#include <random>

#define endl '\n'

using namespace asl;
using namespace std;

int main()
{
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.precision(12);
    cout << fixed;

    point<long double> a, b, c;

    cin >> a >> b >> c;

    cout << circumscribed_circle_triangle(a, b, c) << endl;

    return 0;
}





Measured memory_bytes: 3304