#include <bits/stdc++.h>
using namespace std;
using namespace std;

typedef complex<double> P;
const double EPS = 1e-8;

// 誤差を加味した符号判定
int sign(double a){
    if(a > EPS) return +1;
    if(a < -EPS) return -1;
    return 0;
}

// 比較演算子
namespace std{
    bool operator < (const P& a, const P& b) {
        return real(a) != real(b) ? real(a) < real(b) : imag(a) < imag(b);
    }
}

// 内積・外積
double dot(P a, P b){
    return real(conj(a) * b);
}
double cross(P a, P b){
    return imag(conj(a) * b);
}

// OAとOBのなす符号付き角度 [-pi, pi]
// example : (1, 0), (0, 1) -> pi/2
double angle(P a, P b){
    return arg(conj(a) * b);
}

// aをc中心にb[rad]回転
// verify : not yet.
P rotate(P a, double b, P c = P()){
    return (a - c) * polar(1.0, b) + c;
}

// 直線ABに対する点Cの位置
int ccw(P a, P b, P c) {
    b -= a; c -= a;
    if (cross(b, c) > +EPS)   return +1; // 反時計回り
    if (cross(b, c) < -EPS)   return -1; // 時計回り
    if (dot(b, c) < 0)     return +2; // c--a--b の順番で一直線上
    if (norm(b) < norm(c)) return -2; // a--b--c の順番で一直線上
    return 0;                         // 点が線分ab上にある
}

enum{ OUT, ON, IN };
struct L : public vector<P> {
    L(){}
    L(const P& a, const P& b) {
        push_back(a); push_back(b);
    }
    P vector() const {
        return back() - front();
    }
};

// 注意: 端点で交わったり直線が重なったりする場合も交差していると判定する

// 二直線の平行判定
// verify : aoj0021
bool paralell(L l, L m){
    return sign(cross(l.vector(), m.vector())) == 0;
}

// 二直線の同一判定
bool equalLL(L l, L m){
    return sign(cross(l.vector(), m[0] - l[0])) == 0;
}

// 直線と点の交差判定
bool iLP(L l, P p) {
    // 直線lとl[0]からpへの直線が平行
    return sign(cross(l.vector(), p - l[0])) == 0;
}

// 線分と点の交差判定(端点の処理に注意)
// verify : aoj1279
bool iSP(L s, P p) {
    return ccw(s[0], s[1], p) == 0;
}

// 直線と線分の交差判定(線分が重なっている時に注意)
bool iLS(L l, L s) {
    // 直線lについて、線分sの端点が異なる側にある
    return sign(cross(l.vector(), s[0] - l[0]) * cross(l.vector(), s[1] - l[0])) <= 0;
}

// 二つの線分の交差判定(線分が重なっている時や端点の処理に注意)
bool iSS(L s, L t) {
    return ccw(s[0], s[1], t[0]) * ccw(s[0], s[1], t[1]) <= 0 &&
        ccw(t[0], t[1], s[0]) * ccw(t[0], t[1], s[1]) <= 0;
}


// 点pから直線lに対する射影
P proj(L l, P p){
    double t = dot(p - l[0], l.vector()) / norm(l.vector());
    return l[0] + t * l.vector();
}

// 点pの直線lに関する反射
P refl(L l, P p){
    return 2.0 * proj(l, p) - p;
}

// 直線と点の距離
double dLP(L l, P p){
    // return abs(p - projection(l, p));
    return abs(cross(l.vector(), p - l[0])) / abs(l.vector());
}

// 線分と点の距離 ( not verified !!! )
double dSP(L s, P p){
    if(sign(dot(s.vector(), p - s[0])) <= 0) return abs(p - s[0]);
    if(sign(dot(-s.vector(), p - s[1])) <= 0) return abs(p - s[1]);
    return dLP(s, p);
}

// 直線と直線の距離
double dLL(L l, L m){
    // 平行でないときは0, 平行のときは垂線の長さ
    return paralell(l, m) ? dLP(l, m[0]) : 0;
}

// 直線と線分の距離
double dLS(L l, L s){
    if(iLS(l, s)) return 0;
    return min(dLP(l, s[0]), dLP(l, s[1]));
}

// 線分と線分の距離
double dSS(L s, L t){
    if(iSS(s, t)) return 0;
    return min({dSP(s, t[0]), dSP(s, t[1]), dSP(t, s[0]), dSP(t, s[1])});
}

// 直線と直線の交点
P pLL(L l, L m){
    double A = cross(l.vector(), m.vector());
    double B = cross(l.vector(), l[1] - m[0]);
    if(sign(A) == 0 && sign(B) == 0) return m[0]; // 二直線が重なっている
    if(sign(A) == 0) assert(false); // 直線が交わらない
    return m[0] + m.vector() * B / A;
}

typedef vector<P> Polygon; // 反時計回りを仮定

// Polygonの要素へのアクセス
P curr(const Polygon& a, int x){ return a[x]; }
P next(const Polygon& a, int x){ return a[(x + 1) % a.size()]; }
P prev(const Polygon& a, int x){ return a[(x - 1 + a.size()) % a.size()]; }

// 点が多角形のどこにあるのか判定する
// verify : aoj0012
int contains(const Polygon& A, const P& p){
    // 点pから半直線をひき、辺と交差する回数を数える
    bool in = false;
    for(int i = 0; i < A.size(); i++){
        P a = curr(A, i) - p;
        P b = next(A, i) - p;
        if(a.imag() > b.imag()) swap(a, b);
        // aからbの直線がy=0と交わり、その交点は原点の右側である
        if(a.imag() <= 0 && 0 < b.imag() && cross(a, b) < 0){ 
            in = !in;
        }
        if(sign(cross(a, b)) == 0 && sign(dot(a, b)) <= 0) return ON;
    }
    return in ? IN : OUT;
}

// 多角形の面積
// verify : aoj0079 aoj1100
double area(const Polygon& A) {
    double res = 0;
    for(int i = 0; i < A.size(); i++){
        res += cross(curr(A, i), next(A, i));
    }
    return abs(res) / 2.0;
}

// 凸包
Polygon convex_hull(vector<P> ps) {
    int n = ps.size(), k = 0;
    sort(ps.begin(), ps.end());
    vector<P> ch(2*n);
    for (int i = 0; i < n; ch[k++] = ps[i++]){ // lower-hull
        while (k >= 2 && ccw(ch[k-2], ch[k-1], ps[i]) <= 0) --k;
    }
    for (int i = n-2, t = k+1; i >= 0; ch[k++] = ps[i--]){ // upper-hull
        while (k >= t && ccw(ch[k-2], ch[k-1], ps[i]) <= 0) --k;
    }
    ch.resize(k-1);
    return ch;
}

bool is_convex(const Polygon& A){
    for(int i = 0; i < A.size(); i++){
        if(ccw(prev(A, i), curr(A, i), next(A, i)) > 0) return false;
    }
    return true;
}

// 凸多角形の直線による切断。直線の左側だけ残す
// verify : aoj1283
Polygon convex_cut(const Polygon& A, L l){
    Polygon B;
    for(int i = 0; i < A.size(); i++){
        P a = curr(A, i), b = next(A, i);
        if(ccw(l[0], l[1], a) != -1) B.push_back(a); //Aが直線lの右側でない
        if(ccw(l[0], l[1], a) * ccw(l[0], l[1], b) < 0)
            B.push_back(pLL(l, L(a, b)));
    }
    return B;
}
// 垂直二等分線
// verify: maximamcup2013 D
L bisector(P a, P b){
    P mid = (a + b) / 2.0;
    P vec = (mid - a) * P(0.0, 1.0);
    return L(mid, mid + vec);
}
// 点集合psのうちs番目のボロノイ領域
// verify: maximamcup2013 D
Polygon voronoi_cell(Polygon A, const vector<P>& ps, int s){
    for(int i = 0; i < ps.size(); i++){
        if(i != s) A = convex_cut(A, bisector(ps[s], ps[i]));
    }
    return A;
}
struct Circle {
    P p;
    double r;
    Circle() {}
    Circle(P p, double r) : p(p), r(r) { }
};

// 円と点の内外判定
int contains(const Circle& C, const P& p){
    double d = abs(C.p - p);
    if(sign(d - C.r) > 0) return OUT;
    if(sign(d - C.r) == 0) return ON;
    return IN;
}

// 円と線分の交差判定(境界を含む)
// Verified: AOJ 0129
bool iCS(const Circle& C, const L& l){
    int c1 = contains(C, l[0]);
    int c2 = contains(C, l[1]);
    if(c1 > c2) swap(c1, c2);

    // (OUT, OUT) (OUT, ON) (OUT, IN) (ON, ON) (ON, IN) (IN, IN) の6通り
    if(c1 == OUT && c2 == IN) return true;
    if(c1 == IN  && c2 == IN) return false;
    if(c1 == ON) return true; // (接するとき) 
    double d = dSP(l, C.p);
    if(sign(d - C.r) < 0) return true;
    if(sign(d - C.r) == 0) return true; // (接するとき)
    if(sign(d - C.r) > 0) return false;
}

// 二つの円の交差判定(接する時を含む)
bool iCC(const Circle& C, const Circle& D){
    // 円の中心同士の距離が、半径の和以下であり、半径の差以上である
    double e = abs(C.p - D.p);
    return sign(e - (C.r + D.r)) <= 0 && sign(e - abs(C.r - D.r)) >= 0;
}

// 円と直線の交点
// verify : aoj2045
vector<P> pLC(const L &l, const Circle &c) {
    vector<P> res;
    P center = proj(l, c.p);
    double d = abs(center - c.p);
    double tt = c.r * c.r - d * d;
    if(tt < 0 && tt > -EPS) tt = 0;
    if(tt < 0) return res;
    double t = sqrt(tt);
    P vect = l.vector();
    vect /= abs(vect);
    res.push_back(center - vect * t);
    if (t > EPS) {
        res.push_back(center + vect * t);
    }
    return res;
}

// 円と線分の交点
vector<P> pSC(const L &s, const Circle &c) {
    vector<P> ret;
    vector<P> nret = pLC(s, c);
    for (int i = 0; i < nret.size(); i++) {
        if (iSP(s, nret[i])) ret.push_back(nret[i]);
    }
    return ret;
}

// 円と円の交点
// verify : aoj1183
vector<P> pCC(Circle a, Circle b){
    vector<P> res;

    double l = abs(b.p - a.p);

    if(sign(l) == 0 && sign(a.r - b.r) == 0) assert(false); // 解が無限に存在する
    if(sign(l - abs(a.r - b.r)) < 0 || sign(l - (a.r + b.r)) > 0) return res; // 解が存在しない

    double th1 = arg(b.p - a.p);
    if(sign(l - abs(a.r - b.r)) == 0 || sign(l - (a.r + b.r)) == 0){
        res.push_back(a.p + polar(a.r, th1));
    }else {
        double th2 = acos( (a.r * a.r - b.r * b.r + l * l) / (2 * a.r * l) );
        res.push_back(a.p + polar(a.r, th1 - th2));
        res.push_back(a.p + polar(a.r, th1 + th2));
    }
    return res;
}

// 2点を通る半径rの円の中心
// verify : aoj1132
vector<P> touching_circle2(P a, P b, double r){
    vector<P> res;

    double d = abs(b - a);
    if(d > 2 * r) return res;

    P mid = 0.5 * (a + b);
    P dir = polar(sqrt(r * r - d * d / 4), arg(b - a) + M_PI / 2);
    res.push_back(mid + dir);
    res.push_back(mid - dir);
    return res;
}

// 3点を通る円
Circle touching_circle3(P a, P b, P c){
    // ２つの垂直二等分線の交点が円の中心
    P mid_ab = (a + b) / 2.0;
    L bis_ab(mid_ab, (mid_ab - a) * P(0.0, 1.0));
    P mid_bc = (b + c) / 2.0;
    L bis_bc(mid_bc, (mid_bc - b) * P(0.0, 1.0));

    assert(!paralell(bis_ab, bis_bc)); 

    P center = pLL(bis_ab, bis_bc);
    return Circle(center, abs(a - center));
}

// 円と円の共通部分の面積を求める．
// ref: nya3j
double cc_area(const Circle& c1, const Circle& c2) {
    double d = abs(c1.p - c2.p);
    if (c1.r + c2.r < d + EPS) {
        return 0.0;
    } else if (d < abs(c1.r - c2.r) + EPS) {
        double r = min(c1.r, c2.r); // 元は c1.r >? c2.r だった．
        return r * r * M_PI;
    } else {
        double rc = (d*d + c1.r*c1.r - c2.r*c2.r) / (2*d);
        double theta = acos(rc / c1.r);
        double phi = acos((d - rc) / c2.r);
        return c1.r*c1.r*theta + c2.r*c2.r*phi - d*c1.r*sin(theta);
    }
}
// 円の接線 (中心から偏角thの点で接する接線)
// verified: AOJ 2201 Immortal Jewels 
L circle_tangent(const Circle& C, double th){
    P p0 = C.p + polar(C.r, th);
    P p1 = p0 + polar(1.0, th + M_PI / 2);
    return L(p0, p1);
}

// 二つの円の共通接線 (Cの中心から接点へのベクトルの偏角を返す)
// verified: AOJ 2201 Immortal Jewels 
// 参考: http://geom.web.fc2.com/geometry/circle-circle-tangent.html
vector<double> common_tangents(const Circle& C, const Circle& D){
    vector<double> res;
    P v = D.p - C.p;
    double l = abs(v); // 二円の中心間の距離
    double a = arg(v); // 二円の中心間の偏角
    if(sign(l - abs(C.r - D.r)) > 0){
        // 交わる or 外接 or 離れている
        // 二つの外側接線
        double a1 = acos((C.r - D.r) / l);
        res.push_back(a + a1);
        res.push_back(a - a1);
        if(sign(l - (C.r + D.r)) > 0){
            // 離れている
            // 二つの内側接線
            double a2 = acos((C.r + D.r) / l);
            res.push_back(a + a2);
            res.push_back(a - a2);
        }
    }
    if((sign(l - abs(C.r - D.r)) == 0 || sign(l - (C.r + D.r)) == 0) && sign(l) != 0){
        // 内接 or 外接
        // 一つの接線
        res.push_back(a);
    }
    return res;
}

// 1点を通る円の接線( pがCの外側にあることが前提条件 )
// verified : AOJ 2579
vector<L> tangents_through_point(const Circle& C, const P& p){
    vector<L> tangents;
    double d = abs(C.p - p);
    // d ^ 2 == r ^ 2 + e ^ 2
    double e = sqrt(d * d - C.r * C.r); // 点pと円の接点の距離
    // d * sin(th) = r
    double th = asin(C.r / d);
    P q1 = p + (C.p - p) * polar(1.0, +th) * e / d;
    P q2 = p + (C.p - p) * polar(1.0, -th) * e / d;
    tangents.push_back(L(p, q1));
    tangents.push_back(L(p, q2));
    return tangents;
}
int main(){
    int N;
    while(cin>>N && N){
        double sx, sy, gx, gy;
        cin>>sx>>sy>>gx>>gy;
        P sp(sx, sy);
        P gp(gx, gy);
        double ans = 1e8;
        L route(sp, gp);
        for(int i = 0; i < N; i++) {
            double mx, my, nx, ny, h;
            cin>>mx>>my>>nx>>ny>>h;
            if(mx <= sx && sx <= nx && my <= sy && sy <= ny) ans = 0;
            L ls[4];
            ls[0] = {{mx, my}, {nx, my}};
            ls[1] = {{mx, my}, {mx, ny}};
            ls[2] = {{mx, ny}, {nx, ny}};
            ls[3] = {{nx, ny}, {nx, my}};
            for(int j = 0; j < 4; j++) {
                L l = ls[j];
                double dist = dSS(route, l);
                if(dist == 0) ans = 0;
                double radian;
                if(dist - EPS < h) radian = dist;
                else radian = (h*h + dist*dist)/(2*h);
                ans = min(ans, radian);
            }
        }
        printf("%.10lf\n", ans);
    }
    return 0;
}

Measured memory_bytes: 1276