Snuke received a triangle as a birthday present. The coordinates of the three vertices were (x_1, y_1), (x_2, y_2), and (x_3, y_3).

He wants to draw two circles with the same radius inside the triangle such that the two circles do not overlap (but they may touch). Compute the maximum possible radius of the circles.

Constraints

* 0 ≤ x_i, y_i ≤ 1000
* The coordinates are integers.
* The three points are not on the same line.

Input

The input is given from Standard Input in the following format:


x_1 y_1
x_2 y_2
x_3 y_3


Output

Print the maximum possible radius of the circles. The absolute error or the relative error must be at most 10^{-9}.

Examples

Input

0 0
1 1
2 0


Output

0.292893218813


Input

3 1
1 5
4 9


Output

0.889055514217
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.InputMismatchException;

public class Main {
    InputStream is;

    int __t__ = 1;
    int __f__ = 0;
    int __FILE_DEBUG_FLAG__ = __f__;
    String __DEBUG_FILE_NAME__ = "src/A2";

    FastScanner in;
    PrintWriter out;

    public void solve() {
        int x1 = in.nextInt(), y1 = in.nextInt();
        int x2 = in.nextInt(), y2 = in.nextInt();
        int x3 = in.nextInt(), y3 = in.nextInt();

        double d12 = dist(x1, y1, x2, y2);
        double d13 = dist(x1, y1, x3, y3);
        double d23 = dist(x2, y2, x3, y3);

        double a = Math.max(d12, Math.max(d13, d23));
        double r = calcRadius(x1, y1, x2, y2, x3, y3);
        System.out.println((a * r) / (2 * r + a));
    }
/*
    private double calc(int x1, int y1, int x2, int y2, int x3, int y3) {
        double lo = 0, hi = 1.0;
        for (int i = 1; i < 9999; i++) {
            double c1 = calc2(x1, y1, x2, y2, x3, y3, (i - 1) / 10000.0);
            double c2 = calc2(x1, y1, x2, y2, x3, y3, i / 10000.0);
            double c3 = calc2(x1, y1, x2, y2, x3, y3, (i + 1) / 10000.0);
            if (c2 > c1 && c2 > c3) {
                System.out.println(i + " " + calc2(x1, y1, x2, y2, x3, y3, i / 10000.0));
            }
        }

        for (int i = 0; i < 100; i++) {
            double mid1 = lo + (hi - lo) / 3.0;
            double mid2 = lo + 2.0 * (hi - lo) / 3.0;
            double r1 = calc2(x1, y1, x2, y2, x3, y3, mid1);
            double r2 = calc2(x1, y1, x2, y2, x3, y3, mid2);
            // System.out.println(mid1 + " " + mid2);
            if (r1 < r2) {
                lo = mid1;
            } else {
                hi = mid2;
            }
        }
        return calc2(x1, y1, x2, y2, x3, y3, lo);
    }

    private double calc2(int x1, int y1, int x2, int y2, int x3, int y3, double rate) {
        double cx = x2 + (x3 - x2) * rate;
        double cy = y2 + (y3 - y2) * rate;
        double r1 = calcRadius(x1, y1, x2, y2, cx, cy);
        double r2 = calcRadius(x1, y1, x3, y3, cx, cy);
        return Math.min(r1, r2);
    }
*/

    private double calcRadius(double x1, double y1, double x2, double y2, double x3, double y3) {
        double d12 = dist(x1, y1, x2, y2);
        double d13 = dist(x1, y1, x3, y3);
        double d23 = dist(x2, y2, x3, y3);

        double s = (d12 + d13 + d23) / 2;
        double area = Math.sqrt(s * (s - d12) * (s - d13) * (s - d23));
        return area / s;
    }

    private double dist(double x1, double y1, double x2, double y2) {
        double dx = x1 - x2;
        double dy = y1 - y2;
        return Math.sqrt(dx * dx + dy * dy);
    }

    /* MOD_CALCULATION */
    static int MOD = 1_000_000_007;
    static long ADD(long a, long b) {
        return (a + b) % MOD;
    }

    static long SUB(long a, long b) {
        return (a - b + MOD) % MOD;
    }

    static long MULT(long a, long b) {
        return ((a % MOD) * (b % MOD)) % MOD;
    }

    static long POW(long a, long x) {
        long res = 1;
        for ( ; x > 0; x >>= 1) {
            if (x % 2 == 1) res = MULT(res, a);
            a = MULT(a, a);
        }

        return res;
    }

    static long DIV(long a, long b) {
        return MULT(a, POW(b, MOD - 2));
    }
    /* end */

    public void run() {
        if (__FILE_DEBUG_FLAG__ == __t__) {
            try {
                is = new FileInputStream(__DEBUG_FILE_NAME__);
            } catch (FileNotFoundException e) {
                // TODO 自動生成された catch ブロック
                e.printStackTrace();
            }
            System.out.println("FILE_INPUT!");
        } else {
            is = System.in;
        }
        in = new FastScanner(is);
        out = new PrintWriter(System.out);

        solve();
    }

    public static void main(final String[] args) {
        new Main().run();
    }

    class FastScanner {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;

        public FastScanner(InputStream stream) {
            this.stream = stream;
            // stream = new FileInputStream(new File("dec.in"));

        }

        int read() {
            if (numChars == -1)
                throw new InputMismatchException();
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (numChars <= 0)
                    return -1;
            }
            return buf[curChar++];
        }

        boolean isSpaceChar(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        boolean isEndline(int c) {
            return c == '\n' || c == '\r' || c == -1;
        }

        int nextInt() {
            return Integer.parseInt(next());
        }

        int[] nextIntArray(int n) {
            int[] array = new int[n];
            for (int i = 0; i < n; i++)
                array[i] = nextInt();

            return array;
        }

        int[][] nextIntMap(int n, int m) {
            int[][] map = new int[n][m];
            for (int i = 0; i < n; i++) {
                map[i] = in.nextIntArray(m);
            }
            return map;
        }

        long nextLong() {
            return Long.parseLong(next());
        }

        long[] nextLongArray(int n) {
            long[] array = new long[n];
            for (int i = 0; i < n; i++)
                array[i] = nextLong();

            return array;
        }

        long[][] nextLongMap(int n, int m) {
            long[][] map = new long[n][m];
            for (int i = 0; i < n; i++) {
                map[i] = in.nextLongArray(m);
            }
            return map;
        }

        double nextDouble() {
            return Double.parseDouble(next());
        }

        double[] nextDoubleArray(int n) {
            double[] array = new double[n];
            for (int i = 0; i < n; i++)
                array[i] = nextDouble();

            return array;
        }

        double[][] nextDoubleMap(int n, int m) {
            double[][] map = new double[n][m];
            for (int i = 0; i < n; i++) {
                map[i] = in.nextDoubleArray(m);
            }
            return map;
        }

        String next() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            StringBuilder res = new StringBuilder();
            do {
                res.appendCodePoint(c);
                c = read();
            } while (!isSpaceChar(c));
            return res.toString();
        }

        String[] nextStringArray(int n) {
            String[] array = new String[n];
            for (int i = 0; i < n; i++)
                array[i] = next();

            return array;
        }

        String nextLine() {
            int c = read();
            while (isEndline(c))
                c = read();
            StringBuilder res = new StringBuilder();
            do {
                res.appendCodePoint(c);
                c = read();
            } while (!isEndline(c));
            return res.toString();
        }
    }
}
