#include<bits/stdc++.h>
#define ALL(c) (c).begin(),(c).end()
#define EACH(i,c) for(auto i=(c).begin();i!=(c).end();++i)
using namespace std;
#define int long long

const double eps = 1e-10;

const double PI = atan(1) * 4;
// 大小比較用
int sgn(double a){
    return a < -eps ? -1: a > eps ? 1: 0;
}
int sgn(double a, double b){
    return sgn(b - a);
}
typedef complex<double> P;
typedef vector<P> Polygon;
#define curr(p,i) p[i]
#define next(p,i) p[(i+1)%p.size()]
struct Line : public vector<P> {
    Line(P a, P b) {
        push_back(a); push_back(b);
    }
};
struct Segment : public Line {
    Segment(const P &a, const P &b) : Line(a,b) { }
};
struct Circle{
    P o;
    double r;
    Circle() { }
    Circle(const P &o, double r) : o(o), r(r) { }
    Circle(double x, double y, double r) : o(x,y), r(r) { }
    // 点の包含（境界を含む）
    bool contains(const P &p) const{
        return sgn(abs(p-o), r) <= 0;
    }
    // 内部（境界を含まず）
    bool inside(const P &p) const{
        return sgn(abs(p-o), r) < 0;
    }
    // 点pを通る接線．pからoへ向かうベクトルの左側がfirstに入る
    pair<Line,Line> tangent(const P &p) const{
        vector<Line> res;
        double d = abs(p - o), s = r*r / d, t = sqrt(r*r-s*s);
        P q = o + s/d * (p - o), e = (p - o) * P(0, 1/d);
        return make_pair(Line(p,q+e*t), Line(p,q-e*t));
    }
};

bool near(const P &a, const P &b){
    return !sgn(abs(a-b));
}
// sort用．ClosestPair用にX,Yに分けている
bool lessX(const P &a, const P &b){
    if(sgn(real(a), real(b))) return real(a) < real(b);
    if(sgn(imag(a), imag(b))) return imag(a) < imag(b);
    return false;
}
bool lessY(const P &a, const P &b){
    if(sgn(imag(a), imag(b))) return imag(a) < imag(b);
    if(sgn(real(a), real(b))) return real(a) < real(b);
    return false;
}
double dot(const P &a, const P &b){
    return real(conj(a) * b);
}
double cross(const P &a, const P &b){
    return imag(conj(a) * b);
}
int ccw(const P &a, P b, P c){
    assert(!near(a, b));
    b -= a; c -= a;
    if (sgn(cross(b, c)) > 0)        return +1;  // ccw
    if (sgn(cross(b, c)) < 0)        return -1;  // cw
    if (sgn(dot(b, c)) < 0)          return +2;  // c-a-b
    if (sgn(norm(b), norm(c)) > 0)   return -2;  // a-b-c
    return 0;                                   // a-c-b
}
bool parallel(const Line &s, const Line &t){
    return !sgn(abs(cross(s[1]-s[0], t[1]-t[0])));
}
bool orthogonal(const Line &s, const Line &t){
    return !sgn(abs(dot(s[1]-s[0], t[1]-t[0])));
}
// 点aの直線s上への射影
P projection(const Line &s, const P &a){
    P v = s[1] - s[0];
    return s[0] + dot(v, a - s[0]) / abs(v) / abs(v) * v;
}
// 直線sに対する点aの鏡映
P reflection(const Line &s, const P &a){
    P p = projection(s, a);
    return 2.0 * p - a;
}

// 直線と点の距離
double distanceLP(const Line &s, const P &p){
    return abs(cross(p-s[0],s[1]-s[0])) / abs(s[1]-s[0]);
}

// 円と円の交点（aからbへ向かう左側がfirst）
pair<P,P> crosspointCC(const Circle &a, const Circle &b){
    double d = abs(b.o - a.o);
    double x = (a.r * a.r - b.r * b.r + d * d) / (d * 2);
    P v = (b.o - a.o) * (1.0 / d);
    P n = P(0,1) * v;
    double h = sqrt(a.r * a.r - x * x);
    return make_pair(a.o + v * x + n * h,
                     a.o + v * x - n * h);
}

P func(P a, P b, P c, double l) {
    pair<P,P> q = crosspointCC(Circle(a + (b - a) * (1.0 / abs(b - a)), 10000), Circle(a + (c - a) * (1.0 / abs(c - a)), 10000));
    P u = q.second, t = projection(Line(a, b), u);
    double r = abs(u - t) / abs(u - a);
    double k = l / r;
    P v = a + (u - a) * (1.0 / abs(u - a)) * k;

    return v;
}

bool judge(double l, vector<P> &p) {
    if (ccw(p[0], p[1], p[2]) < 0) {
        swap(p[1], p[2]);
    }
    for(int i = 0; i < 3; ++i) {
        P a = p[i], b = p[(i + 1) % 3], c = p[(i + 2) % 3];

        P v = func(a, b, c, l);
        P w = func(b, c, a, l);
        if (ccw(b, c, v) != 1 || distanceLP(Line(b, c), v) < l - eps) {
            continue;
        }
        if (ccw(c, a, w) != 1 || distanceLP(Line(c, a), w) < l - eps) {
            continue;
        }
        if (abs(w - v) < 2 * l - eps) {
            continue;
        }
        return true;
    }
    return false;
}

void solve(std::vector<long long> x, std::vector<long long> y){
    vector<P> p(3);
    for(int i = 0; i < 3; ++i) p[i] = P(x[i], y[i]);
    double l = 0, u = 1000;
    for(int _ = 0; _ < 300; ++_) {
        double c = (l + u) / 2;
        if (judge(c, p)) {
            l = c;
        } else {
            u = c;
        }
    }
    printf("%.12f\n", l);
}

signed main(){
    std::vector<long long> x(3);
    std::vector<long long> y(3);
    for(int i = 0 ; i < 3 ; i++){
        scanf("%lld",&x[i]);
        scanf("%lld",&y[i]);
    }
    solve(std::move(x), std::move(y));
    return 0;
}

Measured memory_bytes: 256