#include <bits/stdc++.h>
using namespace std;

#define ll long long
#define sd(x) scanf("%d", &(x))
#define pii pair<int, int>
#define F first
#define S second
#define all(c) ((c).begin()), ((c).end())
#define sz(x) ((int)(x).size())
#define ld long double

template<class T,class U>
ostream& operator<<(ostream& os,const pair<T,U>& p){
	os<<"("<<p.first<<", "<<p.second<<")";
	return os;
}

template<class T>
ostream& operator <<(ostream& os,const vector<T>& v){
	os<<"{";
	for(int i = 0;i < (int)v.size(); i++){
		if(i)os<<", ";
		os<<v[i];
	}
	os<<"}";
	return os;
}

#ifdef LOCAL
#define cerr cout
#else
#endif

#define TRACE

#ifdef TRACE
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1>
void __f(const char* name, Arg1&& arg1){
	cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args){
	const char* comma = strchr(names + 1, ',');cerr.write(names, comma - names) << " : " << arg1<<" | ";__f(comma+1, args...);
}
#else
#define trace(...)
#endif

double INF = 1e100;
double EPS = 1e-12;

struct PT { 
  double x, y; 
  PT() {}
  PT(double x, double y) : x(x), y(y) {}
  PT(const PT &p) : x(p.x), y(p.y)    {}
  PT operator + (const PT &p)  const { return PT(x+p.x, y+p.y); }
  PT operator - (const PT &p)  const { return PT(x-p.x, y-p.y); }
  PT operator * (double c)     const { return PT(x*c,   y*c  ); }
  PT operator / (double c)     const { return PT(x/c,   y/c  ); }
  void input(){
      int p, q; scanf("%d %d", &p, &q);
      x = p; y = q;
  }
};

double dot(PT p, PT q)     { return p.x*q.x+p.y*q.y; }
double dist2(PT p, PT q)   { return dot(p-q,p-q); }
double cross(PT p, PT q)   { return p.x*q.y-p.y*q.x; }
double norm(PT p){return sqrt(dot(p, p));}
ostream &operator<<(ostream &os, const PT &p) {
  os << "(" << p.x << "," << p.y << ")"; 
}

// rotate a point CCW or CW around the origin
PT RotateCCW90(PT p)   { return PT(-p.y,p.x); }
PT RotateCW90(PT p)    { return PT(p.y,-p.x); }
PT RotateCCW(PT p, double t) { 
  return PT(p.x*cos(t)-p.y*sin(t), p.x*sin(t)+p.y*cos(t)); 
}

PT ComputeLineIntersection(PT a, PT b, PT c, PT d) {
  b=b-a; d=c-d; c=c-a;
  assert(dot(b, b) > EPS && dot(d, d) > EPS);
  return a + b*cross(c, d)/cross(b, d);
}

int main(){
    PT A, B, C;
    A.input(); B.input(); C.input();   
    if(cross(B - A, C - B) < 0){
        PT tmp = C;
        C = B;
        B = tmp;
    }
    PT AB = B - A, BC = C - B, CA = A - C;
    PT p_AB = RotateCCW90(AB) / norm(AB), p_BC = RotateCCW90(BC) / norm(BC), p_CA = RotateCCW90(CA) / norm(CA);
    double lo = 0, hi = 10000;
    while(abs(hi - lo) > 1e-10){
        double R = (lo + hi) / 2.; 
        PT _A = A + p_AB * R; // _A, AB
        PT _B = B + p_BC * R; // _B, BC
        PT _C = C + p_CA * R; // _C, CA
        PT p1 = ComputeLineIntersection(_A, _A + AB, _B, _B + BC);
        double c = cross(CA, p1 - _C);
        // trace(c, lo, hi, CA, p1 - _C);
        if(c < 0){
            hi = R;
            continue;
        }
        PT p2 = ComputeLineIntersection(_B, _B + BC, _C, _C + CA);
        PT p3 = ComputeLineIntersection(_C, _C + CA, _A, _A + AB);
        double mx = max(dist2(p1, p2), max(dist2(p2, p3), dist2(p3, p1)));
        if(mx >= 4 * R * R) lo = R;
        else hi = R;
    }
    printf("%.10lf\n", lo);
}

Measured memory_bytes: 256