#include <iostream>
#include <algorithm>
#include <bitset>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#include <array>
#include <unordered_map>
#include <complex>
#include <deque>
#include <cassert>
#include <cmath>
#include <functional>
#include <iomanip>
#include <chrono>
#include <random>
#include <numeric>
#include <tuple>
#include <cstring>
using namespace std;

#define forr(x,arr) for(auto&& x:arr)
#define _overload3(_1,_2,_3,name,...) name
#define _rep2(i,n) _rep3(i,0,n)
#define _rep3(i,a,b) for(int i=int(a);i<int(b);++i)
#define rep(...) _overload3(__VA_ARGS__,_rep3,_rep2,)(__VA_ARGS__)
#define _rrep2(i,n) _rrep3(i,0,n)
#define _rrep3(i,a,b) for(int i=int(b)-1;i>=int(a);i--)
#define rrep(...) _overload3(__VA_ARGS__,_rrep3,_rrep2,)(__VA_ARGS__)
#define all(x) (x).begin(),(x).end()
#define bit(n) (1LL<<(n))
#define sz(x) ((int)(x).size())
#define TEN(n) ((ll)(1e##n))
#define fst first
#define snd second

string DBG_DLM(int &i){return(i++==0?"":", ");}
#define DBG_B(exp){int i=0;os<<"{";{exp;}os<<"}";return os;}
template<class T>ostream&operator<<(ostream&os,vector<T>v);
template<class T>ostream&operator<<(ostream&os,set<T>v);
template<class T>ostream&operator<<(ostream&os,queue<T>q);
template<class T>ostream&operator<<(ostream&os,priority_queue<T>q);
template<class T,class K>ostream&operator<<(ostream&os,pair<T,K>p);
template<class T,class K>ostream&operator<<(ostream&os,map<T,K>mp);
template<class T,class K>ostream&operator<<(ostream&os,unordered_map<T,K>mp);
template<int I,class TPL>void DBG(ostream&os,TPL t){}
template<int I,class TPL,class H,class...Ts>void DBG(ostream&os,TPL t){os<<(I==0?"":", ")<<get<I>(t);DBG<I+1,TPL,Ts...>(os,t);}
template<class T,class K>void DBG(ostream&os,pair<T,K>p,string delim){os<<"("<<p.first<<delim<<p.second<<")";}
template<class...Ts>ostream&operator<<(ostream&os,tuple<Ts...>t){os<<"(";DBG<0,tuple<Ts...>,Ts...>(os,t);os<<")";return os;}
template<class T,class K>ostream&operator<<(ostream&os,pair<T,K>p){DBG(os,p,", ");return os;}
template<class T>ostream&operator<<(ostream&os,vector<T>v){DBG_B(forr(t,v){os<<DBG_DLM(i)<<t;});}
template<class T>ostream&operator<<(ostream&os,set<T>s){DBG_B(forr(t,s){os<<DBG_DLM(i)<<t;});}
template<class T>ostream&operator<<(ostream&os,queue<T>q){DBG_B(for(;q.size();q.pop()){os<<DBG_DLM(i)<<q.front();});}
template<class T>ostream&operator<<(ostream&os,priority_queue<T>q){DBG_B(for(;q.size();q.pop()){os<<DBG_DLM(i)<<q.top();});}
template<class T,class K>ostream&operator<<(ostream&os,map<T,K>m){DBG_B(forr(p,m){os<<DBG_DLM(i);DBG(os,p,"->");});}
template<class T,class K>ostream&operator<<(ostream&os,unordered_map<T,K>m){DBG_B(forr(p,m){os<<DBG_DLM(i);DBG(os,p,"->");});}
#define DBG_OVERLOAD(_1,_2,_3,_4,_5,_6,macro_name,...)macro_name
#define DBG_LINE(){char s[99];sprintf(s,"line:%3d | ",__LINE__);cerr<<s;}
#define DBG_OUTPUT(v){cerr<<(#v)<<"="<<(v);}
#define DBG1(v,...){DBG_OUTPUT(v);}
#define DBG2(v,...){DBG_OUTPUT(v);cerr<<", ";DBG1(__VA_ARGS__);}
#define DBG3(v,...){DBG_OUTPUT(v);cerr<<", ";DBG2(__VA_ARGS__);}
#define DBG4(v,...){DBG_OUTPUT(v);cerr<<", ";DBG3(__VA_ARGS__);}
#define DBG5(v,...){DBG_OUTPUT(v);cerr<<", ";DBG4(__VA_ARGS__);}
#define DBG6(v,...){DBG_OUTPUT(v);cerr<<", ";DBG5(__VA_ARGS__);}
#define DEBUG0(){DBG_LINE();cerr<<endl;}
#ifdef LOCAL
#define out(...){DBG_LINE();DBG_OVERLOAD(__VA_ARGS__,DBG6,DBG5,DBG4,DBG3,DBG2,DBG1)(__VA_ARGS__);cerr<<endl;}
#else
#define out(...)
#endif

using ll=long long;
using pii=pair<int,int>;using pll=pair<ll,ll>;using pil=pair<int,ll>;using pli=pair<ll,int>;
using vs=vector<string>;using vvs=vector<vs>;using vvvs=vector<vvs>;
using vb=vector<bool>;using vvb=vector<vb>;using vvvb=vector<vvb>;
using vi=vector<int>;using vvi=vector<vi>;using vvvi=vector<vvi>;
using vl=vector<ll>;using vvl=vector<vl>;using vvvl=vector<vvl>;
using vd=vector<double>;using vvd=vector<vd>;using vvvd=vector<vvd>;
using vpii=vector<pii>;using vvpii=vector<vpii>;using vvvpii=vector<vvpii>;
template<class A,class B>bool amax(A&a,const B&b){return b>a?a=b,1:0;}
template<class A,class B>bool amin(A&a,const B&b){return b<a?a=b,1:0;}
ll ri(){ll l;cin>>l;return l;} string rs(){string s;cin>>s;return s;}

#define PI (3.14159265358979323846)
#define EPS (1e-7)
 
#define curr(P, i) P[(i) % P.size()]
#define next(P, i) P[(i+1) % P.size()]
#define prev(P, i) P[(i+P.size()-1) % P.size()]
#define diff(P, i) (next(P,i) - curr(P,i))
#define EQ(x,y) (fabs((x)-(y))<EPS)
#define GE(x,y) ((x)+EPS>(y))
#define LE(x,y) ((x)<(y)+EPS)
enum { OUT, ON, IN };
 
typedef complex<double> P;
typedef vector<P> G;
 
namespace std{
  bool operator < (const P& a, const P& b) {
    return real(a) != real(b) ? real(a) < real(b) : imag(a) < imag(b);
  }
}
 
double cross(const P& a, const P& b) {
  return imag(conj(a)*b);
}
double dot(const P& a, const P& b) {
  return real(conj(a)*b);
}
 
struct L : public vector<P> {
  L(){}
  L(const P &a, const P &b) {
    push_back(a); push_back(b);
  }
};
 
struct C {
  P p; double r;
  C(const P &p, double r) : p(p), r(r) { }
};
 
int ccw(P a, P b, P c) {
  b -= a; c -= a;
  if (cross(b, c) > EPS)   return +1;
  if (cross(b, c) < -EPS)   return -1;
  if (dot(b, c) < -EPS)     return +2;
  if (norm(b) < norm(c)+EPS) return -2;
  return 0;
}
 
bool intersectLL(const L &l, const L &m) {
  return abs(cross(l[1]-l[0], m[1]-m[0])) > EPS ||
         abs(cross(l[1]-l[0], m[0]-l[0])) < EPS;
}
bool intersectLS(const L &l, const L &s) {
  return cross(l[1]-l[0], s[0]-l[0])*
         cross(l[1]-l[0], s[1]-l[0]) < EPS;
}
bool intersectLP(const L &l, const P &p) {
  return abs(cross(l[1]-p, l[0]-p)) < EPS;
}
bool intersectSS(const L &s, const L &t) {
  return ccw(s[0],s[1],t[0])*ccw(s[0],s[1],t[1]) <= 0 &&
         ccw(t[0],t[1],s[0])*ccw(t[0],t[1],s[1]) <= 0;
}
bool intersectSP(const L &s, const P &p) {
  return abs(s[0]-p)+abs(s[1]-p)-abs(s[1]-s[0]) < EPS;
}
 
P projection(const L &l, const P &p) {
  double t = dot(p-l[0], l[0]-l[1]) / norm(l[0]-l[1]);
  return l[0] + t*(l[0]-l[1]);
}
P reflection(const L &l, const P &p) {
  return p + 2.0 * (projection(l, p) - p);
}
double distanceLP(const L &l, const P &p) {
  return abs(p - projection(l, p));
}
double distanceLL(const L &l, const L &m) {
  return intersectLL(l, m) ? 0 : distanceLP(l, m[0]);
}
double distanceLS(const L &l, const L &s) {
  if (intersectLS(l, s)) return 0;
  return min(distanceLP(l, s[0]), distanceLP(l, s[1]));
}
double distanceSP(const L &s, const P &p) {
  const P r = projection(s, p);
  if (intersectSP(s, r)) return abs(r - p);
  return min(abs(s[0] - p), abs(s[1] - p));
}
double distanceSS(const L &s, const L &t) {
  if (intersectSS(s, t)) return 0;
  return min(min(distanceSP(s, t[0]), distanceSP(s, t[1])),
             min(distanceSP(t, s[0]), distanceSP(t, s[1])));
}
P crossP(const L &l, const L &m) {
  double A = cross(l[1] - l[0], m[1] - m[0]);
  double B = cross(l[1] - l[0], l[1] - m[0]);
  if (abs(A) < EPS && abs(B) < EPS) return m[0];
  if (abs(A) < EPS) assert(false);
  return m[0] + B / A * (m[1] - m[0]);
}
 
vector<P> crossPLC(const L &l, const C &c){
  vector<P> res;
  P p = projection(l, c.p);
  double d1 = abs(p - c.p);
  if(EQ(d1, c.r)){
    res.push_back(p);
    return res;
  }
  if(d1 > c.r){
    return res;
  }
  double d2 = sqrt(c.r*c.r - d1*d1);
  P v = d2/abs(l[1] - l[0]) * (l[1] - l[0]);
  res.push_back(p + v);
  res.push_back(p - v);
  return res;
}
 
#define sq(x) ((x)*(x))
 
vector<P> crossPCC(const C &c1, const C &c2){
  vector<P> res;
  P v = c2.p - c1.p;
  double d = abs(v);
  if(d < EPS){
    if(EQ(c1.r, c2.r)){
      res.push_back(c1.p + P(c1.r, 0));
    }
    return res;
  }
  vector<double> thetas;
  if(EQ(d, c1.r + c2.r)){
    thetas.push_back(0);
  }else if(EQ(d, c1.r - c2.r)){
    thetas.push_back(0);
  }else if(EQ(d, c2.r - c1.r)){
    thetas.push_back(PI);
  }else if(d > c1.r + c2.r || d < abs(c1.r - c2.r)){
    return res;
  }else{
    double t = acos((sq(c1.r) + sq(d) - sq(c2.r))
      / (2.0 * c1.r * d));
    thetas.push_back(t);
    thetas.push_back(-t);
  }
  for (int i=0; i < (int) thetas.size(); i++){
    res.push_back(c1.p + c1.r/d * v
      * P(cos(thetas[i]), sin(thetas[i])));
  }
  return res;
}
 
 
vector<L> tangentPC(const P& p, const C& c){
  vector<L> res;
  P v = c.p - p;
  double d1 = abs(v), d2;
  if(EQ(d1, c.r)){
    d2 = sqrt(sq(d1) - sq(c.r));
    P q = p + v * P(cos(PI/2.0), sin(PI/2.0));
    res.push_back(L(q, p));
    return res;
  }else if(d1 < c.r){
    return res;
  }else{
    d2 = sqrt(sq(d1) - sq(c.r));
    double t = atan2(c.r, d2);
    P q = p + d2/d1 * v * P(cos(t), sin(t));
    res.push_back(L(p, q));
    q = p + d2/d1 * v * P(cos(-t), sin(-t));
    res.push_back(L(p, q));
    return res;
  }
}
 
vector<L> commontangentCC(const C& c1, const C& c2){
  vector<L> res;
  P v = c2.p - c1.p;
  double d = abs(v);
  if(d < EPS){
    if(EQ(c1.r, c2.r)){
      P q1 = c1.p + P(c1.r, 0);
      P q2 = q1 + P(0, c1.r);
      res.push_back(L(q1, q2));
    }
    return res;
  }
  if(d + EPS <= abs(c1.r - c2.r)){
    return res;
  }else if(EQ(d, c1.r - c2.r)){
    P q1 = c1.r/d * v;
    P q2 = q1 + v * P(cos(PI/2.0), sin(PI/2.0));
    res.push_back(L(q1, q2));
    return res;
  }else if(EQ(d, c2.r - c1.r)){
    P q1 = c2.r/d * -v;
    P q2 = q1 + v * P(cos(PI/2.0), sin(PI/2.0));
    res.push_back(L(q1, q2));
    return res;
  }else{
    double t1 = asin((c2.r - c1.r)/d) + PI/2.0;
    P q1 = c1.p + c1.r/d * v * P(cos(t1), sin(t1));
    P q2 = c2.p + c2.r/d * v * P(cos(t1), sin(t1));
    res.push_back(L(q1, q2));
    q1 = c1.p + c1.r/d * v * P(cos(-t1), sin(-t1));
    q2 = c2.p + c2.r/d * v * P(cos(-t1), sin(-t1));
    res.push_back(L(q1, q2));
    if(d + EPS <= c1.r + c2.r){
      return res;
    }else if(EQ(d, c1.r + c2.r)){
      P q3 = c1.p + c1.r/d * v;
      P q4 = q3 + v * P(cos(PI/2.0), sin(PI/2.0));
      res.push_back(L(q3, q4));
    }else{
      double t2 = acos((c1.r + c2.r)/d);
      P q3 = c1.p + c1.r/d * v * P(cos(t2), sin(t2));
      P q4 = c2.p - c2.r/d * v * P(cos(t2), sin(t2));
      res.push_back(L(q3, q4));
      q3 = c1.p + c1.r/d * v * P(cos(-t2), sin(-t2));
      q4 = c2.p - c2.r/d * v * P(cos(-t2), sin(-t2));
      res.push_back(L(q3, q4));
    }
  }
  return res;
}
 
vector<C> tangentcircleLL(const L& l, const L& m, const double& r){
  vector<C> res;
  if(abs(cross(l[1]-l[0], m[1]-m[0])) < EPS){
    double d = distanceLL(l, m);
    if(EQ(d, r*2.0)){
      P p = P(l[0] + r/abs(l[1]-l[0]) * (l[1]-l[0])
        * P(cos(PI/2), sin(PI/2)));
      res.push_back(C(p, r));
    }
    return res;
  }
  P p = crossP(l, m);
  double t1 = (arg(m[1]-m[0]) - arg(l[1]-l[0])) / 2.0;
  P v1 = abs(r/sin(t1)) / abs(l[1]-l[0]) * (l[1]-l[0])
    * P(cos(t1), sin(t1));
  double t2 = PI/2 - t1;
  P v2 = abs(r/sin(t2)) / abs(m[1]-m[0]) * (m[1]-m[0])
    * P(cos(t2), sin(t2));
  res.push_back(C(p + v1, r));
  res.push_back(C(p + v2, r));
  res.push_back(C(p - v1, r));
  res.push_back(C(p - v2, r));
  return res;
}
 
#undef sq
 
int contains(const G& g, const P& p) {
  bool in = false;
  for (int i = 0; i < (int) g.size(); ++i) {
    P a = curr(g,i) - p, b = next(g,i) - p;
    if (imag(a) > imag(b)) swap(a, b);
    if (imag(a) <= 0 && 0 < imag(b))
      if (cross(a, b) < 0) in = !in;
    if (cross(a, b) == 0 && dot(a, b) <= 0) return ON;
  }
  return in ? IN : OUT;
}
 
#define d(k) (dot(p[k], l[1] - l[0]))
P extreme(const vector<P> &p, const L &l) {
  int k = 0;
  for (int i = 1; i < (int) p.size(); ++i)
    if (d(i) > d(k)) k = i;
  return p[k];
}
 
#undef d
 
double area2(const G& p) {
  double A = 0;
  for (int i = 0; i < (int) p.size(); ++i) 
    A += cross(curr(p, i), next(p, i));
  return A;
}
 
vector<P> convex_hull(vector<P> ps) {
  int n = ps.size(), k = 0;
  sort(ps.begin(), ps.end());
  vector<P> ch(2*n);
  for (int i = 0; i < n; ch[k++] = ps[i++])
    while (k >= 2 && ccw(ch[k-2], ch[k-1], ps[i]) <= 0) --k;
  for (int i = n-2, t = k+1; i >= 0; ch[k++] = ps[i--])
    while (k >= t && ccw(ch[k-2], ch[k-1], ps[i]) <= 0) --k;
  ch.resize(k-1);
  return ch;
}
 
bool isconvex(const G &P) {
  for (int i = 0; i < (int) P.size(); ++i)
    if (ccw(prev(P, i), curr(P, i), next(P, i)) > 0) return false;
  return true;
}
 
G convex_cut(const G& p, const L& l) {
  G Q;
  for (int i = 0; i < (int) p.size(); ++i) {
    P A = curr(p, i), B = next(p, i);
    if (ccw(l[0], l[1], A) != -1) Q.push_back(A);
    if (ccw(l[0], l[1], A)*ccw(l[0], l[1], B) < 0)
      Q.push_back(crossP(L(A, B), l));
  }
  return Q;
}
 
int convex_contains(const G &Q, const P &p) {
  const int n = Q.size();
  P g = (Q[0] + Q[n/3] + Q[2*n/3]) / 3.0;
  int a = 0, b = n;
  while (a+1 < b) {
    int c = (a + b) / 2;
    if (cross(Q[a]-g, Q[c]-g) > 0) {
      if (cross(Q[a]-g, p-g) > 0 && cross(Q[c]-g, p-g) < 0) b = c;
      else                                                  a = c;
    } else {
      if (cross(Q[a]-g, p-g) < 0 && cross(Q[c]-g, p-g) > 0) a = c;
      else                                                  b = c;
    }
  }
  b %= n;
  if (cross(Q[a] - p, Q[b] - p) < 0) return 0;
  if (cross(Q[a] - p, Q[b] - p) > 0) return 2;
  return 1;
}
 
bool intersect_1pt(const P& a, const P& b,
                   const P& c, const P& d, P &r) {
  double D =  cross(b - a, d - c);
  if (EQ(D, 0)) return false;
  double t =  cross(c - a, d - c) / D;
  double s = -cross(a - c, b - a) / D;
  r = a + t * (b - a);
  return GE(t, 0) && LE(t, 1) && GE(s, 0) && LE(s, 1);
}
G convex_intersect(const G &p, const G &Q) {
  const int n = p.size(), m = Q.size();
  int a = 0, b = 0, aa = 0, ba = 0;
  enum { Pin, Qin, Unknown } in = Unknown;
  G R;
  do {
    int a1 = (a+n-1) % n, b1 = (b+m-1) % m;
    double C = cross(p[a] - p[a1], Q[b] - Q[b1]);
    double A = cross(p[a1] - Q[b], p[a] - Q[b]);
    double B = cross(Q[b1] - p[a], Q[b] - p[a]);
    P r;
    if (intersect_1pt(p[a1], p[a], Q[b1], Q[b], r)) {
      if (in == Unknown) aa = ba = 0;
      R.push_back( r );
      in = B > 0 ? Pin : A > 0 ? Qin : in;
    }
    if (C == 0 && B == 0 && A == 0) {
      if (in == Pin) { b = (b + 1) % m; ++ba; }
      else           { a = (a + 1) % m; ++aa; }
    } else if (C >= 0) {
      if (A > 0) { if (in == Pin) R.push_back(p[a]); a = (a+1)%n; ++aa; }
      else       { if (in == Qin) R.push_back(Q[b]); b = (b+1)%m; ++ba; }
    } else {
      if (B > 0) { if (in == Qin) R.push_back(Q[b]); b = (b+1)%m; ++ba; }
      else       { if (in == Pin) R.push_back(p[a]); a = (a+1)%n; ++aa; }
    }
  } while ( (aa < n || ba < m) && aa < 2*n && ba < 2*m );
  if (in == Unknown) {
    if (convex_contains(Q, p[0])) return p;
    if (convex_contains(p, Q[0])) return Q;
  }
  return R;
}
 
double convex_diameter(const G &pt) {
  const int n = pt.size();
  int is = 0, js = 0;
  for (int i = 1; i < n; ++i) {
    if (imag(pt[i]) > imag(pt[is])) is = i;
    if (imag(pt[i]) < imag(pt[js])) js = i;
  }
  double maxd = norm(pt[is]-pt[js]);
 
  int i, maxi, j, maxj;
  i = maxi = is;
  j = maxj = js;
  do {
    if (cross(diff(pt,i), diff(pt,j)) >= 0) j = (j+1) % n;
    else i = (i+1) % n;
    if (norm(pt[i]-pt[j]) > maxd) {
      maxd = norm(pt[i]-pt[j]);
      maxi = i; maxj = j;
    }
  } while (i != is || j != js);
  return maxd; /* farthest pair is (maxi, maxj). */
}
 
#define d(k) (dot(p[k], l[1] - l[0]))
P convex_extreme(const G &p, const L &l) {
  const int n = p.size();
  int a = 0, b = n;
  if (d(0) >= d(n-1) && d(0) >= d(1)) return p[0];
  while (a < b) {
    int c = (a + b) / 2;
    if (d(c) >= d(c-1) && d(c) >= d(c+1)) return p[c];
    if (d(a+1) > d(a)) {
      if (d(c+1) <= d(c) || d(a) > d(c)) b = c;
      else                               a = c;
    } else {
      if (d(c+1) > d(c) || d(a) >= d(c)) a = c;
      else                               b = c;
    }
  }
  return P();
}
#undef d


double solve() {
	vector<P> ps(3);
	rep(i, 3) {
		int x = ri();
		int y = ri();
		ps[i] = {(double)x, (double)y};
	}

	if (ccw(ps[0], ps[1], ps[2]) == 1) {
		swap(ps[0], ps[1]);
	}

	out(ps);

	vector<P> vv(3);
	rep(i, 3) vv[i] = ps[(i+1)%3] - ps[i];
	out(vv);

	vector<P> hou(3);
	rep(i, 3) {
		auto l = abs(vv[i]);
		hou[i] = {vv[i].imag() / l, -vv[i].real() / l};
	}
	out(hou);

	double mimi;
	{
		double a = abs(vv[0]);
		double b = abs(vv[1]);
		double c = abs(vv[2]);
		P o = c/(a+b+c) * ps[1] + a/(a+b+c) * ps[2] + b/(a+b+c) * ps[0];
		mimi = distanceLP(L(ps[0], ps[1]), o);
	}
	out(mimi);

	auto check = [&](double x) -> bool {
		vector<L> segs(3);
		rep(i, 3) {
			P p0 = ps[i];
			P p1 = ps[(i+1)%3];
			P h = hou[i];
			segs[i] = L(p0 + h * x, p1 + h * x);
		}
		out(x, segs);

		vector<P> q(3);
		rep(i, 3) {
			L l0 = segs[i];
			L l1 = segs[(i+1)%3];
			q[i] = crossP(l0, l1);
		}
		out(x, q);

		double ma = 0;
		rep(i, 3) {
			double d = abs(q[i] - q[(i+1)%3]);
			amax(ma, d);
		}
		out(x, ma);
		return ma >= x * 2;
	};

	double ok = 0;
	double ng = mimi;
	
	rep(_, 200) {
		double mid = (ok + ng) / 2;
		bool c = check(mid);
		out(ok, ng, mid, c);
		if (c) ok = mid;
		else ng = mid;
	}


	return ok;
}

void Main() {
	cout << fixed << setprecision(10);
	cout << solve() << endl;
}
signed main() {
	cin.tie(nullptr);
	ios::sync_with_stdio(false);
	Main();
	return 0;
}


Measured memory_bytes: 384