Roll-A-Big-Ball http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=1157

aoj1157.cpp

#include <bits/stdc++.h>
using namespace std;
#define int long long   // <-----!!!!!!!!!!!!!!!!!!!

#define rep(i,n) for (int i=0;i<(n);i++)
#define rep2(i,a,b) for (int i=(a);i<(b);i++)
#define rrep(i,n) for (int i=(n)-1;i>=0;i--)
#define rrep2(i,a,b) for (int i=(a)-1;i>=b;i--)
#define all(a) (a).begin(),(a).end()
#define rall(a) (a).rbegin(),(a).rend()
#define printV(_v) for(auto _x:_v){cout<<_x<<" ";}cout<<endl
#define printVS(_vs) for(auto _x : _vs){cout << _x << endl;}
#define printVV(_vv) for(auto _v:_vv){for(auto _x:_v){cout<<_x<<" ";}cout<<endl;}
#define printP(_p) cout << _p.first << " " << _p.second << endl
#define printVP(_vp) for(auto _p : _vp) printP(_p);

typedef long long ll;
typedef pair<int, int> Pii;
typedef tuple<int, int, int> TUPLE;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<vvi> vvvi;
typedef vector<vector<int>> Graph;
const int inf = 1e9;
const int mod = 1e9 + 7;

typedef complex<double> P;
typedef vector<P> G;
#define here(g, i) g[i]
#define next(g, i) g[(i + 1) % g.size()]
#define prev(g, i) g[(i - 1 + g.size()) % g.size()]
const double EPS = 1e-10;
const double INF = 1e12;
const double PI = acos(-1);

#define dame cout << 0 << endl; return;

struct L {
    P a, b, v;
    L(){}
    L(P _a, P _b) : a(_a), b(_b), v(b - a) {}
    L(double _ax, double _ay, double _bx, double _by) : L(P(_ax, _ay), P(_bx, _by)) {}
};

double cross(P a, P b) {
    return imag(conj(a) * b);
}

double dot(P a, P b) {
    return real(conj(a) * b);
}

int ccw(P p0, P p1, P p2) {
    if (cross(p1 - p0, p2 - p0) > 0) return +1; // counter-clockwise
    if (cross(p1 - p0, p2 - p0) < 0) return -1; // clockwise
    if (dot(p1 - p0, p2 - p0) < 0) return +2;   // online_back
    if (dot(p0 - p1, p2 - p1) < 0) return -2;   // online_front
    return 0;                                   // on_segment
}

bool intersectSS(L l1, L l2) {
    return (ccw(l1.a, l1.b, l2.a) * ccw(l1.a, l1.b, l2.b) <= 0 &&
            ccw(l2.a, l2.b, l1.a) * ccw(l2.a, l2.b, l1.b) <= 0);
}

bool intersectSG(L l, G g) {
    int n = g.size();
    rep(i, n) {
        if (intersectSS(l, L(here(g, i), next(g, i)))) {
            return true;
        }
    }
    return false;
}

double distanceLP(L l, P p) {
    return abs(cross(l.v, p - l.a)) / abs(l.v);
}

double distanceSP(L l, P p) {
    if (dot(l.v, p - l.a) < 0) return abs(p - l.a);
    if (dot(-l.v, p - l.b) < 0) return abs(p - l.b);
    return distanceLP(l, p);
}

double distanceSS(L l1, L l2) {
    if (intersectSS(l1, l2)) return 0;
    double d = INF;
    d = min(d, distanceSP(l1, l2.a));
    d = min(d, distanceSP(l1, l2.b));
    d = min(d, distanceSP(l2, l1.a));
    d = min(d, distanceSP(l2, l1.b));
    return d;
}

double distanceSG(L l, G g) {
    double d = INF;
    rep(i, g.size()) {
        d = min(d, distanceSS(l, L(here(g, i), next(g, i))));
    }
    return d;
}

bool within(double x, double a, double b) {
    return a <= x && x <= b;
}

void solve(int n) {
    double sx, sy, ex, ey;
    cin >> sx >> sy >> ex >> ey;
    L seg_ball(sx, sy, ex, ey);
    vector<G> rect(n);
    vector<double> h(n);

    rep(i, n) {
        double minx, miny, maxx, maxy;
        cin >> minx >> miny >> maxx >> maxy >> h[i];
        rect[i].emplace_back(minx, miny);
        rect[i].emplace_back(maxx, miny);
        rect[i].emplace_back(maxx, maxy);
        rect[i].emplace_back(minx, maxy);

        if (within(sx, minx, maxx) && within(sy, miny, maxy) && within(ex, minx, maxx) && within(ey, miny, maxy)) {
            dame;
        }
    }

    rep(i, n) {
        if (intersectSG(seg_ball, rect[i])) {
            dame;
        }
    }

    auto check = [&](double r){
        rep(i, n) {
            P p;
            double d = distanceSG(seg_ball, rect[i]);
            if (r < h[i]) {
                if (r > d) return false;
            } else {
                if (h[i] > r - sqrt(r*r - d*d)) return false;
            }
        }
        return true;
    };

    double lb = 0, ub = 1e5;
    rep(i, 100) {
        double mid = (lb + ub) / 2;
        (check(mid) ? lb : ub) = mid;
    }

    cout << fixed << setprecision(20) << lb << endl;
}

signed main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(0);

    int n;
    while (cin >> n, n) {
        solve(n);
    }
}