#include <bits/stdc++.h>
using namespace std;
#define all(a) begin(a),end(a)
#define sz(a) int(size(a))
#define rep(i,a,b) for(int i=(a);i<(b);++i)
using vi = vector<int>;
using ll = long long;
using ld = double;
using pll = pair<ll,ll>;

struct Point{
    typedef Point P;
    ld x, y;
    Point(ld x=0, ld y=0): x(x), y(y) {}
    bool operator<(P p) const {
        return tie(x, y) < tie(p.x, p.y);
    }
    P operator+(P p) const { return P(x + p.x, y + p.y); }
    P operator-(P p) const { return P(x - p.x, y - p.y); }
    P operator*(ld d) const { return P(x * d, y * d); }
    P operator/(ld d) const { return P(x / d, y / d); }
    ld dist2() const { return x*x + y*y; }
    ld dist() const { return sqrtl(dist2()); }
};

using P = Point;
using Tri = array<P, 3>;

const int NUM_ITS = 85;
const int MAX_X = 1e4;

// ld gss(ld a, ld b, ld (*f)(ld)) {
template<class F>
ld gss(ld a, ld b, F& f, bool printCoord=false){
    ld r = (sqrt(5) - 1) / 2, eps = 1e-9;
    ld x1 = b - r * (b - a), x2 = a + r * (b - a);
    ld f1 = f(x1), f2 = f(x2);

    // switched to fixed iterations
    while(b - a > eps)
    // for(int it = 0; it < NUM_ITS; ++it)
        if(f1 < f2) {
            b = x2;
            x2 = x1;
            f2 = f1;
            x1 = b - r * (b - a);
            f1 = f(x1);
        } else {
            a = x1;
            x1 = x2;
            f1 = f2;
            x2 = a + r * (b - a);
            f2 = f(x2);
        }
    if(printCoord) cout << a << endl;
    return f(a);
}

pair<ld, ld> getRange(P& A, P& B, P& C, ld x){
    // subproblem to Mag
    ld tAC = (x - A.x) / (C.x - A.x);
    ld y1 = (A + (C - A) * tAC).y, y2;
    if(x <= B.x) {
        ld tAB = (x - A.x) / (B.x - A.x);
        y2 = (A + (B - A) * tAB).y;
    } else {
        ld tBC = (x - B.x) / (C.x - B.x);
        y2 = (B + (C - B) * tBC).y;
    }
    if(y1 > y2) swap(y1, y2);
    return {y1, y2};
}

void solve(){
    Tri initTri;
    for(int i = 0; i < 3; ++i){
        ld x, y;
        cin >> x >> y;
        initTri[i] = P(x, y);
    }

    // takes in triangle, tern searches (x, y), runs getCost(Tri tri, P p)
    auto solveTri = [&](Tri& tri, auto& getCost) -> ld {
        sort(all(tri));

        // tern search x, y
        ld lx = tri[0].x, rx = tri[2].x;

        auto fOfX = [&](ld x) -> ld {
            auto [ly, ry] = getRange(tri[0], tri[1], tri[2], x);

            auto fOfY = [&](ld y) -> ld {
                P p(x, y);
                return getCost(tri, p);
            };

            return gss(ly, ry, fOfY);
        };

        return gss(lx, rx, fOfX);
    };

    auto getSumDistsCost = [&](Tri& tri, P& p) -> ld {
        ld out = 0;
        for(P q : tri) out += (p - q).dist();
        return out;
    };

    auto getHouseCost = [&](Tri& tri, P& p) -> ld {
        ld out = 0;
        for(int i = 0; i < 3; ++i){
            for(int j = i + 1; j < 3; ++j){
                Tri newTri = Tri{tri[i], tri[j], p};
                out = max(out, solveTri(newTri, getSumDistsCost));
            }
        }
        return out;
    };

    ld ans = solveTri(initTri, getHouseCost);

    cout << setprecision(12) << fixed << ans << "\n";
}

int main(){
    cin.tie(0)->sync_with_stdio(0);
    cin.exceptions(cin.failbit);

    // int t; cin >> t; while(t--)
    solve();

    return 0;
}