#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <algorithm>
#include <vector>
#include <iostream>
using namespace std;

#define EPS (1e-10)
#define equals(a, b) (fabs((a) - (b)) < EPS)
#define PI acos(-1)
#define INF (1e9 + 7)

class Point {
public:
    double x, y;
    Point(double x = 0.0, double y = 0.0) : x(x), y(y) {}

    Point operator + (Point p) {
        return Point(x + p.x, y + p.y);
    }
    Point operator - (Point p) {
        return Point(x - p.x, y - p.y);
    }
    Point operator * (double c) {
        return Point(c * x, c * y);
    }
    Point operator / (double c) {
        return Point(x / c, y / c);
    }
    bool operator < (const Point &p) {
        return (x != p.x ? x < p.x : y < p.y);
    }
    bool operator == (const Point &p) {
        return (fabs(x - p.x) < EPS && fabs(y - p.y) < EPS);
    }
    bool operator != (const Point &p) {
        return (fabs(x - p.x) > EPS || fabs(y - p.y) > EPS);
    }

    double norm() {
        return (x * x + y * y);
    }
    double abs() {
        return sqrt(norm());
    }
};

typedef Point Vector;

double dot(Vector a, Vector b) {
    return (a.x * b.x + a.y * b.y);
}

double cross(Vector a, Vector b) {
    return (a.x * b.y - a.y * b.x);
}

double norm(Vector a) {
    return (a.x * a.x + a.y * a.y);
}

double abs(Vector a) {
    return sqrt(norm(a));
}

class Segment {
public:
    Point p1, p2;
    Segment(Point p1 = Point(), Point p2 = Point()) : p1(p1), p2(p2) {}
};

typedef Segment Line;

class Circle {
public:
    Point c;
    double r;
    Circle(Point c = Point(), double r = 0.0) : c(c), r(r) {}
};

double distL(Line l, Point p) {
    return abs(cross(l.p2 - l.p1, p - l.p1) / abs(l.p2 - l.p1));
}

double distS(Segment s, Point p) {
    if (dot(s.p2 - s.p1, p - s.p1) < 0.0) return abs(p - s.p1);
    if (dot(s.p1 - s.p2, p - s.p2) < 0.0) return abs(p - s.p2);
    return distL(s, p);
}

const int CCW = 1, CW = -1, ONBACK = 2, ONFRONT = -2, ONSEG = 0;

int ccw(Point p0, Point p1, Point p2) {
    Vector a = p1 - p0;
    Vector b = p2 - p0;

    if (cross(a, b) > EPS) return CCW;
    if (cross(a, b) < -EPS) return CW;
    if (dot(a, b) < -EPS) return ONBACK;
    if (a.norm() < b.norm()) return ONFRONT;
    return ONSEG;
}

bool intersect(Point a, Point b, Point c, Point d) {
    return (ccw(a, b, c) * ccw(a, b, d) <= 0 && ccw(c, d, a) * ccw(c, d, b) <= 0);
}


bool intersect(Segment s1, Segment s2) {
    return intersect(s1.p1, s1.p2, s2.p1, s2.p2);
}

double distSS(Segment s1, Segment s2) {
    if (intersect(s1, s2)) return 0.0;
    return min(min(distS(s1, s2.p1), distS(s1, s2.p2)), min(distS(s2, s1.p1), distS(s2, s1.p2)));
}

class Block {
public:
    double lx, ly, rx, ry, h;
    vector<Segment> seg, diagonal;

    Block(double lx = 0.0, double ly = 0.0, double rx = 0.0, double ry = 0.0, double h  = 0.0) : lx(lx), ly(ly), rx(rx), ry(ry), h(h) {}

    void setSeg() {
        seg.resize(4);
        diagonal.resize(2);
        seg[0] = Segment(Point(lx, ly), Point(lx, ry));
        seg[1] = Segment(Point(lx, ry), Point(rx, ry));
        seg[2] = Segment(Point(rx, ry), Point(rx, ly));
        seg[3] = Segment(Point(rx, ly), Point(lx, ly));
        diagonal[0] = Segment(Point(lx, ly), Point(rx, ry));
        diagonal[1] = Segment(Point(lx, ry), Point(rx, ly));
    }
};

inline double dst(double r, double h) {
    if (h >= r) return r;
    return sqrt(r * r - (r - h) * (r - h));
}

int N, sx, sy, ex, ey, a, b, c, d, h;
double ans, min_dist, l, r, mid;
vector<Block> bk;
Segment road;

int main() {

    while (scanf("%d", &N), N) {
        bk.resize(N);
        ans = 1001.0;

        scanf("%d%d%d%d", &sx, &sy, &ex, &ey);
        road = Segment(Point(sx, sy), Point(ex, ey));

        for (int i = 0; i < N; ++i) {
            scanf("%d%d%d%d%d", &a, &b, &c, &d, &h);
            bk[i] = Block(a, b, c, d, h);
            bk[i].setSeg();
        }

        for (int i = 0; i < N; ++i) {
            min_dist = INF;
            for (int j = 0; j < 4; ++j) {
                min_dist = min(min_dist, distSS(Segment(Point(sx, sy), Point(ex, ey)), bk[i].seg[j]));
            }

            if (intersect(bk[i].diagonal[0], road) || intersect(bk[i].diagonal[1], road)) {
                ans = 0.0;
                break;
            }

            //cout << i << " " << min_dist << endl;
            l = 0.0; r = double(ans);
            while (r - l > EPS) {
                mid = (l + r) / 2.0;
                if (min_dist < dst(mid, bk[i].h)) r = mid;
                else l = mid;
            }

            //cout << "l = " << l << endl;

            if (ans == 1001.0) ans = l;
            else ans = min(ans, l);
            //cout << "d = " << dst(ans, bk[i].h) << endl;
            //printf("%.20lf\n", ans);
        }

        printf("%lf\n", ans);

        bk.clear();
    }

    return 0;
}

Measured memory_bytes: 3140