#include <bits/stdc++.h>
#define int long long
#define double long double
#pragma comment(linker, "/STACK:10000000000")
#include <cassert>
#define eps 1e-9

using namespace std;

struct point {
    double x, y;
};

struct line {
    double a, b, c;
};

int sq(const vector<point> & fig) {
    double res = 0;
    for (unsigned i = 0; i < fig.size(); i++) {
        point
            p1 = i ? fig[i - 1] : fig.back(),
            p2 = fig[i];
        res += (p1.x - p2.x) * (p1.y + p2.y);
    }
    return fabs(res);
}

point a[8];

int get_sqrt_triangle(point a, point b, point c) {
    point FIR = {a.x - b.x, a.y - b.y};
    point SEC = {a.x - c.x, a.y - c.y};
    return abs(FIR.x * SEC.y - SEC.x *FIR.y);
}

double dist(point a, point b) {
    return sqrt(pow(a.x - b.x, 2) + pow(a.y - b.y, 2));
}

void in(point &a) {
    cin >> a.x >> a.y;
}

bool point_in_box(point t, point p1, point p2) {
    return  (abs(t.x - min(p1.x, p2.x)) <= eps || min(p1.x, p2.x) <= t.x) &&
        (abs(max(p1.x, p2.x) - t.x) <= eps || max(p1.x, p2.x) >= t.x) &&
        (abs(t.y - min(p1.y, p2.y)) <= eps || min(p1.y, p2.y) <= t.y) &&
        (abs(max(p1.y, p2.y) - t.y) <= eps || max(p1.y, p2.y) >= t.y);
}

point closest_point(line l, point p) {
    double k = (l.a * p.x + l.b * p.y + l.c) / (l.a * l.a + l.b * l.b);
    return point{p.x - l.a * k, p.y - l.b * k};
}

line toline(point p1, point p2) {
    double a = p2.y - p1.y;
    double b = p1.x - p2.x;

    return line{a, b, -a * p1.x - b * p1.y};
}


double dist_point_to_segment(point p, point p1, point p2) {
    point t = closest_point(toline(p1, p2), p);

    if (point_in_box(t, p1, p2))
        return dist(p, t);
    else
        return min(dist(p, p1), dist(p, p2));
}

signed main(void) {
    point a, b, c;
    cin >> a.x >> a.y >> b.x >> b.y >> c.x >> c.y;
    cout << fixed << setprecision(10) << dist_point_to_segment(a, b, c) << '\n';

    return 0;
}