#include <iostream>
#include <cmath>

struct Vector {
    long double x;
    long double y;

    friend Vector operator -(const Vector &a, const Vector &b) {
        return {a.x - b.x, a.y - b.y};
    }
    friend Vector operator +(const Vector &a, const Vector&b) {
        return {a.x + b.x, a.y + b.y};
    }
    friend Vector operator /(const Vector &a, const long double &b) {
        return {a.x/b, a.y/b};
    }
    friend Vector operator~(const Vector&a) {
        return {-a.y, a.x};
    }

    [[nodiscard]] long double norm() const {
        return sqrtl(this->x * this->x + this->y * this->y);
    }

    friend std::ostream &operator << (std::ostream &out, const Vector & a) {
       out << "(" << a.x << ", " << a.y << ")";
       return out;
    }

};

void load_point(Vector &val) {
    std::cin >> val.x >> val.y;
}

long double dabs(long double a) {
    if (a < 0) return -a;
    return a;
}

Vector getX(const Vector &B, const Vector&C, const Vector&v, const Vector&u) {
    long double d = -v.x * C.x - v.y * C.y;
    long double e = -u.x * B.x - u.y * B.y;

    long double y = (v.x * d + u.x * d + v.x * e - v.x * d) / (v.x * u.y - v.x * v.y);
    long double x = (-v.y * y + d) / (v.x);

    return {x, y};
}

long double solve(const Vector &A, const Vector&B, const Vector&C) {
    //Vector AB = (A + B);
    Vector S = (A + B) / 2;
    Vector SC = C - S;
    Vector AS = S - A; // polomer

    Vector u = A - B;
    Vector v = ~u;
    Vector vm = v / (-1.0);
    Vector X = getX(B, C, v, u);
    Vector Y = getX(B, A, v, u);
    Vector Xm = getX(B, C, vm, u);
    Vector Ym = getX(B, A, vm, u);

    Vector CX = X - C;
    Vector CY = Y - C;
    Vector CXm = Xm - C;
    Vector CYm = Ym - C;

    long double smaller1 = std::min(dabs(CX.norm()), dabs(CY.norm()));
    long double smaller2 = std::min(dabs(CXm.norm()), dabs(CYm.norm()));

    long double smaller = std::min(smaller1, smaller2);

    return std::min(smaller, dabs(SC.norm() - AS.norm()));
}

int main() {
    Vector A, B, C;

    load_point(A);
    load_point(B);
    load_point(C);

    long double resA = solve(A, B, C);
    long double resB = solve(B, A, C);
    long double resC = solve(C, B, A);

    std::cout << std::min(resA, std::min(resB, resC)) << std::endl;

    return 0;
}