#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>

using namespace std;
using lint = long long;
using P = pair<lint, lint>;

#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rep1(i, n) for (int i = 1; i < (n); ++i)
#define repn(i, a, b) for(int i = (a); i < (b); ++i)
#define rep_inv(i, n) for (int i = (n); i >= 0; --i)
#define rep_inv1(i, n) for(int i = (n); i >= 1; --i)
#define all(vec) (vec).begin(), (vec).end()
#define cend printf("\n")

constexpr lint Mod = /**/ 1000'000'007LL /*/ 998'244'353LL /**/;
constexpr lint Inf = 4'500'000'000'000'000'007LL; //4.5e18+7
constexpr double Pi = 3.141592653589793;

template<class T> using prique     = priority_queue<T>;
template<class T> using prique_inv = priority_queue<T, vector<T>, greater<T>>;
template<class T> inline bool chmin(T& a, const T& b) {
	if (a > b) {
		a = b;
		return true;
	}
	return false;
}
template<class T> inline bool chmax(T& a, const T& b) {
	if (a < b) {
		a = b;
		return true;
	}
	return false;
}
template<class T> inline istream& operator>>(istream& is, vector<T>& v) { for (auto& e : v) is >> e; return is; }
template<class T> inline ostream& operator<<(ostream& os, const vector<T>& v) {
	size_t i = 0, n = v.size();
	for (const auto& e : v) {
		os << e;
		if (i + 1 < n) os << " ";
		++i;
	}
	return os;
}
template<class T, class U> inline istream& operator>>(istream& is, pair<T, U>& rhs) { return is >> rhs.first >> rhs.second; }
template<class T, class U> inline ostream& operator<<(ostream& os, const pair<T, U>& rhs) { return os << "{" << rhs.first << ", " << rhs.second << "}"; }
template<class T, class U> inline void print(const T& a, const U& b, bool f) {
	if (f) cout << a << "\n";
	else cout << b << "\n";
}
template<class InputIterator> void arrin(InputIterator first, InputIterator last) { for (; first != last; ++first) cin >> (*first); }
template<class InputIterator> void arrout(InputIterator first, InputIterator last) {
	for (; first != last; ++first) {
		cout << (*first) << ((first + 1) != last ? " " : "\n");
	}
}

bool pri(lint x) { 
	for (lint i = 2; i * i <= x; ++i) {
		if (x % i == 0) return false;
	}
	return 1 < x; 
}

lint fact[3'000'000];
void fact_init(lint n, lint m = Mod) {
	if (3'000'000 <= n) return;
	fact[0] = fact[1] = 1;
	for (lint i = 2; i <= n; ++i) {
		fact[i] = i * fact[i - 1] % m;
	}
}

// a * first + b * second = gcd(a, b)
P extgcd(lint a, lint b) {
	lint s = a, sx = 1, sy = 0, t = b, tx = 0, ty = 1;

	while (s % t != 0) {

		lint temp = s / t;
		lint u = s - t * temp;
		lint ux = sx - tx * temp;
		lint uy = sy - ty * temp;

		s = t;
		sx = tx;
		sy = ty;
		t = u;
		tx = ux;
		ty = uy;
	}

	return { tx, ty };
}

lint modinv(lint a, lint m = Mod) {
	lint b = m, u = 1, v = 0;
	while (b != 0) {
		lint t = a / b;
		a -= t * b; swap(a, b);
		u -= t * v; swap(u, v);
	}
	u %= m;
	if (u < 0) u += m;
	return u;
}

lint modpow(lint x, lint n, lint m = Mod) {
	lint res = 1;
	while (n > 0) {
		if (n & 1) res = res * x % m;
		x = x * x % m;
		n >>= 1;
	}
	return res;
}

lint intpow(lint x, lint n) {
	lint res = 1;
	while (n > 0) {
		if (n & 1) res *= x;
		x *= x;
		n >>= 1;
	}
	return res;
}

lint comb(lint n, lint r, lint m = Mod) {
	if (r == 0 || r == n) return 1;
	lint res = fact[n] * modinv(fact[n - r], m) % m * modinv(fact[r], m) % m;
	return res < 0 ? res + m : res;
}

class Factring {
private:

	const lint max_n;
	vector<lint> sieve;

public:

	explicit Factring(lint n) :
		max_n(n), sieve(n)
	{
		iota(sieve.begin(), sieve.end(), 0);

		for (lint i = 2; i * i < n; ++i) {
			if (sieve[i] < i) continue;

			for (lint j = i * i; j < n; j += i) {
				if (sieve[j] == j) sieve[j] = i;
			}
		}
	}

	unordered_map<lint, lint> calc(lint x) const {
		assert(x < max_n);

		unordered_map<lint, lint> res;
		while (x > 1) {
			++res[sieve[x]];
			x /= sieve[x];
		}
		return res;
	}
};

template<class T>
struct Point {
	T x, y;

	Point() = default;
	Point(T x, T y) : x(x), y(y) {}

	template<class U> Point(const Point<U>& p) :
		x(static_cast<T>(p.x)),
		y(static_cast<T>(p.y))
	{}

	bool operator<(const Point& p) const {
		if (x != p.x) return x < p.x;
		return y < p.y;
	}

	Point operator+() const { return *this; }
	Point operator-() const { return Point(-x, -y); }

	Point operator+(const Point& p) const { return Point(*this) += p; }
	Point operator-(const Point& p) const { return Point(*this) -= p; }
	Point operator*(T scalar) const { return Point(*this) *= scalar; }
	Point operator/(T scalar) const { return Point(*this) /= scalar; }

	Point& operator+=(const Point& p) {
		x += p.x; y += p.y;
		return *this;
	}
	Point& operator-=(const Point& p) {
		x -= p.x; y -= p.y;
		return *this;
	}
	Point& operator*=(T scalar) {
		x *= scalar; y *= scalar;
		return *this;
	}
	Point& operator/=(T scalar) {
		assert(scalar != T(0));
		x /= scalar; y /= scalar;
		return *this;
	}

	T dot(const Point& p) const { return x * p.x + y * p.y; }
	T cross(const Point& p) const { return x * p.y - y * p.x; }

	double distanceFrom(const Point& p) const {
		return hypot(x - p.x, y - p.y);
	}
	T distanceFromSq(const Point& p) const {
		return (x - p.x) * (x - p.x) + (y - p.y) * (y - p.y);
	}

	double length() const { return hypot(x, y); }
	T lengthSq() const { return x * x + y * y; }

	double angle() const { return atan2(y, x); }
	double angle(const Point& v) const { return fabs(atan2(cross(v), dot(v))); }
	double angle(const Point& a, const Point& b) const { return (a - *this).angle(b - *this); }

	Point rotated(double arg) const {
		return { length() * cos(angle() + arg),length() * sin(angle() + arg) };
	}
	Point rotatedAt(const Point& v, double arg) const {
		return (*this - v).rotated(arg) + v;
	}

	void rotate(double arg) { *this = rotated(arg); }
	void rotateAt(const Point& v, double arg) { *this = rotatedAt(v, arg); }

	friend istream& operator>>(istream& is, Point& p) {
		return is >> p.x >> p.y;
	}
	friend ostream& operator<<(ostream& os, const Point& p) {
		return os << "(" << p.x << ", " << p.y << ")";
	}
	friend Point operator*(T scalar, const Point& p) {
		return scalar * p;
	}
};

int main() {
	Point<double> p0, p1, p2;
	cin >> p0 >> p1 >> p2;

	// ∠p1 を max にする
	{
		const double
			arg0 = p0.angle(p1, p2),
			arg1 = p1.angle(p2, p0),
			arg2 = p2.angle(p0, p1),
			max_arg = max({ arg0,arg1,arg2 });

		if (max_arg == arg0) swap(p0, p1);
		else if (max_arg == arg2) swap(p1, p2);
	}

	if (p0.y > p2.y) swap(p0, p2);

	p1 -= p0;
	p2 -= p0;
	p0 = { 0.0,0.0 };

	p1.rotate(-p2.angle());
	p2 = { p2.length(),0.0 };

	p1.y = fabs(p1.y);

	//cout << p0 << " " << p1 << " " << p2 << endl;

	/*if (p2.x < p1.x) {
		p2.rotate(-p1.angle());
		p2.y = fabs(p2.y);

		p1 = { p1.length(),0.0 };

		swap(p1, p2);
	}
	else if (p1.x < 0.0) {
		p0 -= p1;
		p2 -= p1;

		p0.rotate(-p2.angle());
		p0.y = fabs(p0.y);

		p2 = { p2.length(),0.0 };

		swap(p0, p1);
	}*/

	const double arg0_half = 0.5 * p1.angle(), arg2_half = 0.5 * p2.angle(p0, p1);

	const auto& f0 = [=](double x) {
		return tan(arg0_half) * x;
	};

	const double t0 = p2.x / (1 + tan(arg0_half) / tan(arg2_half) + 2.0 * tan(arg0_half));

	printf("%.12lf\n", f0(t0));
}

Measured memory_bytes: 4204