using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.IO;
using System.Text;
using System.Globalization;
using System.Diagnostics;



class Myon
{
    public Myon() { }
    public static int Main()
    {
        new Myon().calc();
        return 0;
    }


    Scanner cin;



    void calc()
    {
        cin = new Scanner();
        int N = 3;
        double[] x = new double[N];
        double[] y = new double[N];
        for (int i = 0; i < N; i++)
        {
            x[i] = cin.nextDouble();
            y[i] = cin.nextDouble();
        }
        P[] ps = new P[3];
        ps[0] = new P(x[0], y[0]);
        ps[1] = new P(x[1], y[1]);
        ps[2] = new P(x[2], y[2]);
        if(P.triangleS(ps[0], ps[1], ps[2]) < 0)
        {
            swap(ref ps[1], ref ps[2]);
        }

        double ans1 = calc2(ps[0], ps[1], ps[2]);
        double ans2 = calc2(ps[1], ps[2], ps[0]);
        double ans3 = calc2(ps[2], ps[0], ps[1]);
        Console.WriteLine(new double[]{ ans1, ans2, ans3 }.Max());
    }

    //swap
    void swap<T>(ref T a, ref T b)
    {
        T c = a;
        a = b;
        b = c;
    } 

    double calc2(P P1, P P2, P P3)
    {
        double ok = 0;
        double ng = 1000;

        for (int i = 0; i < 100; i++)
        {
            double mid = (ok + ng) / 2;
            P V = P2.sub(P1);
            double hyp = V.abs();
            P TV = V.div(hyp);

            P RV = TV.rot90();


            double ok2 = 1;
            double ng2 = 0;
            for (int j = 0; j < 100; j++)
            {
                double mid2 = (ok2 + ng2) / 2;
                P TP1 = P1.add(V.mul(mid2)).add(RV.mul(mid));
                if (P.disLP(P1, P3, TP1) >= mid) ok2 = mid2;
                else ng2 = mid2;
            }

            P NP1 = P1.add(V.mul(ok2)).add(RV.mul(mid));
            P NP2 = NP1.add(TV.mul(mid * 2));
            
            bool check = true;
            if (P.disLP(P1, P3, NP1) < mid) check = false;
            if (P.disLP(P1, P3, NP2) < mid) check = false;
            if (P.disLP(P2, P3, NP1) < mid) check = false;
            if (P.disLP(P2, P3, NP2) < mid) check = false;
            if (check) ok = mid;
            else ng = mid;
        }
        return ok;
    }

    double hypot(double a, double b)
    {
        return Math.Sqrt(a * a + b * b);
    }
}


class P
{
    double x, y;

    public P(double x, double y)
    {
        this.x = x;
        this.y = y;
    }

    public P add(P p)
    {
        return new P(x + p.x, y + p.y);
    }

    public P sub(P p)
    {
        return new P(x - p.x, y - p.y);
    }

    public P mul(double m)
    {
        return new P(x * m, y * m);
    }

    public P div(double d)
    {
        return new P(x / d, y / d);
    }

    public double abs()
    {
        return Math.Sqrt(abs2());
    }

    public double abs2()
    {
        return x * x + y * y;
    }

    public double arg()
    {
        return Math.Atan2(y, x);
    }

    public double dot(P p)
    {
        return x * p.x + y * p.y;
    }

    public double det(P p)
    {
        return x * p.y - y * p.x;
    }

    public double ang(P p)
    {
        return Math.Atan2(det(p), dot(p));
    }

    public P rot90()
    {
        return new P(y, -x);
    }

    public P rot(double d)
    {
        return new P(Math.Cos(d) * x - Math.Sin(d) * y, Math.Sin(d) * x + Math.Cos(d) * y);
    }

    public String toString()
    {
        return "(" + x + "," + y + ")";
    }

    static public double rad(P u, P v)
    {
        double rad = Math.Atan2(u.det(v), u.dot(v));
        if (rad < -EPS) rad += 2 * Math.PI;
        return rad;
    }


    static public double EPS = 1e-9;

    //線分と点の距離
    static double disSP(P p1, P p2, P q)
    {
        if (p2.sub(p1).dot(q.sub(p1)) < EPS) return q.sub(p1).abs();
        if (p1.sub(p2).dot(q.sub(p2)) < EPS) return q.sub(p2).abs();
        return disLP(p1, p2, q);
    }

    //直線と点の距離
    static public double disLP(P p1, P p2, P q)
    {
        return Math.Abs(p2.sub(p1).det(q.sub(p1))) / p2.sub(p1).abs();
    }

    //線分と線分の交差判定
    static bool crsSS(P p1, P p2, P q1, P q2)
    {
        if (Math.Max(p1.x, p2.x) + EPS < Math.Min(q1.x, q2.x)) return false;
        if (Math.Max(q1.x, q2.x) + EPS < Math.Min(p1.x, p2.x)) return false;
        if (Math.Max(p1.y, p2.y) + EPS < Math.Min(q1.y, q2.y)) return false;
        if (Math.Max(q1.y, q2.y) + EPS < Math.Min(p1.y, p2.y)) return false;
        return Math.Sign(p2.sub(p1).det(q1.sub(p1))) * Math.Sign(p2.sub(p1).det(q2.sub(p1))) < EPS
        && Math.Sign(q2.sub(q1).det(p1.sub(q1))) * Math.Sign(q2.sub(q1).det(p2.sub(q1))) < EPS;
    }

    //円と線分の交差判定
    static bool crsCS(P c, double r, P p1, P p2)
    {
        return disSP(p1, p2, c) < r + EPS &&
        (r < c.sub(p1).abs() + EPS || r < c.sub(p2).abs() + EPS);
    }

    //円と円の交差判定
    static bool crsCC(P c1, double r1, P c2, double r2)
    {
        double dis = c1.sub(c2).abs();
        return dis < r1 + r2 + EPS && Math.Abs(r1 - r2) < dis + EPS;
    }

    //四点の同一円周上判定(一直線上はtrue)
    static bool onCir(P p1, P p2, P p3, P p4)
    {
        if (Math.Abs(p2.sub(p1).det(p3.sub(p1))) < EPS) return true;
        P c = ccenter(p1, p2, p3);
        return Math.Abs(c.sub(p1).abs2() - c.sub(p4).abs2()) < EPS;
    }

    static P ccenter(P p1, P p2, P p3)
    {
        return p1;
    }

    //点から直線に下ろした垂線の足
    static P proj(P p1, P p2, P q)
    {
        return p1.add(p2.sub(p1).mul(p2.sub(p1).dot(q.sub(p1)) / p2.sub(p1).abs2()));
    }

    //直線と直線の交点
    static P isLL(P p1, P p2, P q1, P q2)
    {
        double d = q2.sub(q1).det(p2.sub(p1));
        if (Math.Abs(d) < EPS) return null;
        return p1.add(p2.sub(p1).mul(q2.sub(q1).det(q1.sub(p1)) / d));
    }

    //直線と円の交点(p1 に近い順)
    static P[] isCL(P c, double r, P p1, P p2)
    {
        double x = p1.sub(c).dot(p2.sub(p1));
        double y = p2.sub(p1).abs2();
        double d = x * x - y * (p1.sub(c).abs2() - r * r);
        if (d < -EPS) return new P[0];
        if (d < 0) d = 0;
        P q1 = p1.sub(p2.sub(p1).mul(x / y));
        P q2 = p2.sub(p1).mul(Math.Sqrt(d) / y);
        return new P[] { q1.sub(q2), q1.add(q2) };
    }

    //二円の交点
    static P[] isCC(P c1, double r1, P c2, double r2)
    {
        double x = c1.sub(c2).abs2();
        double y = ((r1 * r1 - r2 * r2) / x + 1) / 2;
        double d = r1 * r1 / x - y * y;
        if (d < -EPS) return new P[0];
        if (d < 0) d = 0;
        P q1 = c1.add(c2.sub(c1).mul(y));
        P q2 = c2.sub(c1).mul(Math.Sqrt(d)).rot90();
        return new P[] { q1.sub(q2), q1.add(q2) };
    }

    //点p をから引いた接線の接点
    static P[] tanCP(P c, double r, P p)
    {
        double x = p.sub(c).abs2();
        double d = x - r * r;
        if (d < -EPS) return new P[0];
        if (d < 0) d = 0;
        P q1 = p.sub(c).mul(r * r / x);
        P q2 = p.sub(c).mul(-r * Math.Sqrt(d) / x).rot90();
        return new P[] { c.add(q1.sub(q2)), c.add(q1.add(q2)) };
    }

    //二円の共通接線
    static P[][] tanCC(P c1, double r1, P c2, double r2)
    {
        List<P[]> list = new List<P[]>();
        if (Math.Abs(r1 - r2) < EPS)
        {
            P dir = c2.sub(c1);
            dir = dir.mul(r1 / dir.abs()).rot90();
            list.Add(new P[] { c1.add(dir), c2.add(dir) });
            list.Add(new P[] { c1.sub(dir), c2.sub(dir) });
        }
        else
        {
            P p = c1.mul(-r2).add(c2.mul(r1)).div(r1 - r2);
            P[] ps = tanCP(c1, r1, p);
            P[] qs = tanCP(c2, r2, p);
            for (int i = 0; i < ps.Length && i < qs.Length; i++)
            {
                list.Add(new P[] { ps[i], qs[i] });
            }
        }
        P p2 = c1.mul(r2).add(c2.mul(r1)).div(r1 + r2);
        P[] ps2 = tanCP(c1, r1, p2);
        P[] qs2 = tanCP(c2, r2, p2);
        for (int i = 0; i < ps2.Length && i < qs2.Length; i++)
        {
            list.Add(new P[] { ps2[i], qs2[i] });
        }

        return list.ToArray();
    }

    //２円の共通部分面積
    static double areaCC(P c1, double r1, P c2, double r2)
    {
        double d = c1.sub(c2).abs();
        if (r1 + r2 < d + EPS) return 0;
        if (d < Math.Abs(r1 - r2) + EPS)
        {
            double r = Math.Min(r1, r2);
            return r * r * Math.PI;
        }
        double x = (d * d + r1 * r1 - r2 * r2) / (2 * d);
        double t1 = Math.Acos(x / r1);
        double t2 = Math.Acos((d - x) / r2);
        return r1 * r1 * t1 + r2 * r2 * t2 - d * r1 * Math.Sin(t1);
    }

    static P O = new P(0, 0);
    //原点中心半径r の円と原点とp1,p2 からなる三角形の共通部分面積
    static double areaCT(double r, P p1, P p2)
    {
        P[] qs = isCL(O, r, p1, p2);
        if (qs.Length == 0) return r * r * rad(p1, p2) / 2;
        bool b1 = p1.abs() > r + EPS, b2 = p2.abs() > r + EPS;
        if (b1 && b2)
        {
            if (p1.sub(qs[0]).dot(p2.sub(qs[0])) < EPS &&
            p1.sub(qs[1]).dot(p2.sub(qs[1])) < EPS)
            {
                return (r * r * (rad(p1, p2) - rad(qs[0], qs[1])) + qs[0].det(qs[1])) / 2;
            }
            else
            {
                return r * r * rad(p1, p2) / 2;
            }
        }
        else if (b1)
        {
            return (r * r * rad(p1, qs[0]) + qs[0].det(p2)) / 2;
        }
        else if (b2)
        {
            return (r * r * rad(qs[1], p2) + p1.det(qs[1])) / 2;
        }
        else
        {
            return p1.det(p2) / 2;
        }
    }

    //三角形の符号付き面積の２倍
    public static double triangleS(P P1, P P2, P P3)
    {
        P V1 = P2.sub(P1);
        P V2 = P3.sub(P1);
        return (V1.y * V2.x) - (V1.x * V2.y);
    }
}


class Scanner
{
    string[] s;
    int i;

    char[] cs = new char[] { ' ' };

    public Scanner()
    {
        s = new string[0];
        i = 0;
    }

    public string next()
    {
        if (i < s.Length) return s[i++];
        string st = Console.ReadLine();
        while (st == "") st = Console.ReadLine();
        s = st.Split(cs, StringSplitOptions.RemoveEmptyEntries);
        if (s.Length == 0) return next();
        i = 0;
        return s[i++];
    }

    public int nextInt()
    {
        return int.Parse(next());
    }
    public int[] ArrayInt(int N, int add = 0)
    {
        int[] Array = new int[N];
        for (int i = 0; i < N; i++)
        {
            Array[i] = nextInt() + add;
        }
        return Array;
    }

    public long nextLong()
    {
        return long.Parse(next());
    }

    public long[] ArrayLong(int N, long add = 0)
    {
        long[] Array = new long[N];
        for (int i = 0; i < N; i++)
        {
            Array[i] = nextLong() + add;
        }
        return Array;
    }

    public double nextDouble()
    {
        return double.Parse(next());
    }


    public double[] ArrayDouble(int N, double add = 0)
    {
        double[] Array = new double[N];
        for (int i = 0; i < N; i++)
        {
            Array[i] = nextDouble() + add;
        }
        return Array;
    }
}


Measured memory_bytes: 17488