#include <bits/stdc++.h>

// basis
namespace geometry {
    using real_number = long double;

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

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

        using std::complex< real_number >::complex;
        point(const complex< real_number > &c) : std::complex< real_number >::complex(c) {}

        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 >;
}

// polygon
namespace geometry {
    using polygon = std::vector< point >;
    using polygons = std::vector< polygon >;
}

// 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 >;
}

// angle
namespace geometry {
    real_number get_angle(const point &a, const point &b, const point &c) {
        const point v(b - a), w(c - b);
        real_number alpha = std::atan2(v.imag(), v.real());
        real_number beta  = std::atan2(w.imag(), w.real());
        if (alpha > beta) std::swap(alpha, beta);
        real_number theta = (beta - alpha);
        return std::min(theta, 2 * acos(-1) - theta);
    }
}

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((a * abs(w) + c * abs(v)) / (abs(w) + abs(v)));
        return line(b, p);
    }
}

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 {
    real_number area(const polygon &p) {
        real_number res = 0;
        for (int i = 0; i < p.size(); ++i) {
            res += p[i].cross(p[(i + 1) % p.size()]);
        }
        return res / real_number(2);
    }
}

namespace geometry {
    circle inscribed_circle(const point &a, const point &b, const point &c) {
        real_number A = abs(b - c), B = abs(c - a), C = abs(a - b);
        point x((a * A + b * B + c * C) / (A + B + C));
        //real_number r = real_number(2) * area({a, b, c}) / (A + B + C);
        real_number r = distance(segment(a, b), x);
        return circle(x, r); 
    }

    circle circumscribed_circle(const point &a, const point &b, const point &c) {
        point m1((a + b) / real_number(2)), m2((b + c) / real_number(2));
        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]);

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



Measured memory_bytes: 3336