#include <iostream>
#include <vector>
#include <cstdio>
#include <algorithm>
#include <set>
#include <map>
#include <cassert>
#include <numeric>
#include <string>
#include <cstring>
#include <cmath>
using namespace std;

#ifdef LOCAL
	#define eprintf(...) fprintf(stderr, __VA_ARGS__)
#else
	#define eprintf(...) 42
#endif

typedef long long int int64;


bool doubleEqual(double x, double y)
{
	return fabs(x - y) < 1e-9;
}
bool doubleLess(double x, double y)
{
	return x < y && !doubleEqual(x, y);
}
bool doubleGreater(double x, double y)
{
	return x > y && !doubleEqual(x, y);
}
bool doubleLessOrEqual(double x, double y)
{
	return x < y || doubleEqual(x, y);
}
bool doubleGreaterOrEqual(double x, double y)
{
	return x > y || doubleEqual(x, y);
}
double sqr(double x)
{
	return x * x;
}
double mySqrt(double x)
{
	if (doubleLess(x, 0) )
		throw 42;
	if (x < 0)
		return 0;
	return sqrt(x);
}
int sgn(double x)
{
	if (doubleEqual(x, 0) )
		return 0;
	if (x < 0)
		return -1;
	return 1;
}

const double pi = atan2(0., -1.);

struct Point
{
	double x, y;
	Point() : x(), y() {}
	Point(double _x, double _y) : x(_x), y(_y) {}
	Point operator + (const Point &A) const
	{
		return Point(x + A.x, y + A.y);
	}
	Point operator - (const Point &A) const
	{
		return Point(x - A.x, y - A.y);
	}
	double operator % (const Point &A) const
	{
		return x * A.x + y * A.y;
	}
	double operator * (const Point &A) const
	{
		return x * A.y - y * A.x;
	}
	Point operator * (double a)
	{
		return Point(x * a, y * a);
	}
	Point operator / (double a)
	{
		return Point(x / a, y / a);
	}
	double length() const
	{
		return mySqrt(*this % *this);
	}
	double distTo(Point A)
	{
		return (*this - A).length();
	}
	Point rotate()
	{
		return Point(-y, x);
	}
	Point rotate(double alpha)
	{
		Point v = *this;
		Point u = rotate();
		return v * cos(alpha) + u * sin(alpha);
	}
	Point normalize(double l)
	{
		double len = length();
		if (doubleEqual(len, 0) )
			throw 42;
		return *this * (l / len);
	}
	double getAngle() const
	{
		double xx = atan2(Point(1, 0) * *this, Point(1, 0) % *this);
		if (doubleLess(xx, 0) )
			xx = 2 * pi + xx;
		return xx;
	}

	bool operator < (const Point &A) const
	{
		if (!doubleEqual(x, A.x) ) 
			return x < A.x;
		return doubleLess(y, A.y);
	}
	bool operator == (const Point &A) const
	{
		return doubleEqual(x, A.x) && doubleEqual(y, A.y);
	}
	void read()
	{
		scanf("%lf%lf", &x, &y);
	}
	void print() const
	{
		fprintf(stderr, "%.10lf %.10lf\n", x, y);
	}
	bool onLine(Point A, Point B)
	{
		return doubleEqual( (*this - A) * (B - A), 0);
	}
	bool onSegment(Point A, Point B)
	{
		if (!onLine(A, B) )
			return false;
		if (*this == A || *this == B)
			return true;
		return doubleGreaterOrEqual( (*this - A) % (B - A), 0) && doubleGreaterOrEqual( (*this - B) % (A - B), 0);
	}
};



bool cmp(const Point &A, const Point &B)
{
	return doubleGreater(A * B, 0);
}

bool cmpAngle(const Point &A, const Point &B)
{
	return doubleLess(A.getAngle(), B.getAngle() );
}

Point getInter(Point A, Point B, Point C, Point D, bool &hasInter)
{
	double S1 = (C - A) * (D - A);
	double S2 = (D - B) * (C - B);
	double S = S1 + S2;
	if (doubleEqual(S, 0) )
	{
		hasInter = false;
		return Point();
	}
	hasInter = true;
	return A + (B - A) * (S1 / S);
}


bool test(Point A, Point B, Point C, double r)
{
	Point ab = (B - A).rotate();
	Point bc = (C - B).rotate();
	Point ca = (A - C).rotate();

	Point Aab = A + ab.normalize(r);
	Point Bab = B + ab.normalize(r);

	Point Bbc = B + bc.normalize(r);
	Point Cbc = C + bc.normalize(r);

	Point Cca = C + ca.normalize(r);
	Point Aca = A + ca.normalize(r);

	bool fl;
	Point AC = getInter(Aab, Bab, Bbc, Cbc, fl);
	Point BA = getInter(Cca, Aca, Bbc, Cbc, fl);
	Point BC = getInter(Aab, Bab, Cca, Aca, fl);

	if ((AC - BA) % ca < 0) return false;
	if ((BA - AC) % ab < 0) return false;
	if ((BC - BA) % bc < 0) return false;

	double ans = max({AC.distTo(BC), BC.distTo(BA), BA.distTo(AC)});
//	eprintf("ans = %.5lf\n", ans);
	return ans >= 2 * r;
}


int main(int,  char **)
{
#ifdef LOCAL
	freopen("input.txt", "r", stdin);
//	freopen("output.txt", "w", stdout);
#endif


	Point A, B, C;
	A.read();
	B.read();
	C.read();

	if ((B - A) * (C - A) < 0)
		swap(B, C);

	double l = 0, r = 1e5;

	for (int i = 0; i < 200; i++)
	{
		double m = (l + r) / 2;
		if (test(A, B, C, m) )
			l = m;
		else
			r = m;
	}
	printf("%.10lf\n", l);

	return 0;
}



Measured memory_bytes: 256