#include <iostream>
#include <iomanip>
#include <cmath>
#define REP(i,n) for(int i = 0;i < (n);i++)
const double EPS = 1e-10;
const double INF = 1e+10;
using namespace std;

struct Point{
    double x,y;
    Point operator - (const Point& p){return Point{x-p.x, y-p.y};}
};

struct Segment{
    Point p1,p2;
};



int N;
Segment square[51][4];
Point squarep[51][4];
Segment course;
double height[51];
double norm(Point a){return a.x*a.x + a.y*a.y;}
double abs(Point a){return sqrt(norm(a));}

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

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

int ccw(Point c, Point a, Point b){
    b = b - a;
    a = a - c;
    if(cross(a,b) > EPS)return 1;
    if(cross(a,b) < -EPS)return -1;
    if(dot(a,b) < -EPS) return 2;
    if(norm(a) < norm(b)) return -2;
    return 0;
}

bool intersect(Point p1, Point p2, Point p3, Point p4){
    return ccw(p1,p2,p3)*ccw(p1,p2,p4) <= 0 && ccw(p3,p4,p1)*ccw(p3,p4,p2) <= 0;
}

double gdSP(Segment s, Point p){
    if(dot(s.p2 - s.p1, p - s.p1) < -EPS) return abs(p-s.p1);
    if(dot(s.p1 - s.p2, p - s.p2) < -EPS) return abs(p-s.p2);
    return abs(cross(s.p2 - s.p1, p - s.p1) / abs(s.p2 - s.p1));
}

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

bool contains(int i, Point p){
    bool x = false;
    REP(j,4){
        Point a = squarep[i][j] - p, b = squarep[i][(j+1)%4] - p;
        if(abs(cross(a,b)) < EPS && dot(a,b) < EPS)return true;
        if(a.y > b.y) swap(a,b);
        if(a.y < EPS && EPS < b.y && cross(a,b) >EPS)x = !x;
    }
    return x;
}

bool cangoal(double r){
    REP(i,N){
        //????????????????????????
        if(contains(i, course.p1) || contains(i, course.p2)) return false;
        
        double coursedist = INF;
        REP(j,4){
            coursedist = min(getdist(course, square[i][j]), coursedist);
        }
        double balldist;
        if(height[i] < r){
            balldist = sqrt(2*r*height[i] - height[i]*height[i]);
        }else{
            balldist = r;
        }
        if(coursedist < balldist) return false;
    }
    return true;
}

int main(){
    while(cin >> N,N){
        double sx, sy, ex, ey;
        cin >> sx >> sy >> ex >> ey;
        course = Segment{Point{sx, sy}, Point{ex, ey} };
        REP(i,N){
            double x1, y1, x2, y2;
            cin >> x1 >> y1 >> x2 >> y2 >> height[i];
            REP(d,4){
                squarep[i][d] = Point{x1, y1};
                if(d & 1){
                    square[i][d] = Segment{Point{x1, y1}, Point{x1, y2} };
                    swap(x1,x2);
                }else{
                    square[i][d] = Segment{Point{x1, y1}, Point{x2, y1} };
                    swap(y1,y2);
                }
            }
        }
        double l = 0.0, r = 1001.0;
        for(int ct = 0;ct < 100;ct++){
            double mid = (l + r)/2;
            if(cangoal(mid)) l = mid;
            else r = mid;
        }
        if(l < EPS)cout << 0 << endl;
        else cout << fixed << setprecision(8) << l << endl;
    }
}

Measured memory_bytes: 3264