#include <bits/stdc++.h>

#define REP(i,n) for(int i=0;i<(int)(n);i++)

using namespace std;

typedef long double ld;
typedef complex<ld> P;
typedef vector<P> VP;
const ld eps = 1e-8, pi = acos(-1.0);

#define EQ(a,b) (abs((a)-(b))<eps)

ld dot (P a, P b) { return real(conj(a) * b); }
ld cross (P a, P b) { return imag(conj(a) * b); }

namespace std {
  bool operator<(const P &lhs, const P &rhs) {
    return lhs.real() == rhs.real() ? lhs.imag() < rhs.imag() : lhs.real() < rhs.real();
  }
}

// Line
class L{
public:
  P a, b;
  L (P aa, P bb) { a = aa; b = bb; }
  L (ld ax, ld ay, ld bx, ld by) { a = P(ax, ay); b = P(bx, by); }
};

int ccw (P a, P b, P c) {
  b -= a; c -= a;
  if (cross(b, c) > eps) return 1;   // counter clockwise
  if (cross(b, c) < -eps) return -1; // clockwise
  if (dot(b, c) < 0) return 2;       // c--a--b on line
  if (norm(b) < norm(c)) return -2;  // a--b--c on line
  return 0;                          // a--c--b on line
}

bool isis_ss(L s, L t) {
  return ccw(s.a, s.b, t.a) * ccw(s.a, s.b, t.b) <= 0 &&
         ccw(t.a, t.b, s.a) * ccw(t.a, t.b, s.b) <= 0;
}

bool isis_sp(L s, P p) {
  return abs(s.a - p) + abs(s.b - p) - abs(s.b - s.a) < eps;
}

P proj(L l, P p) {
  ld t = dot(p - l.a, l.a - l.b) / norm(l.a - l.b);
  return l.a + t * (l.a - l.b);
}

ld dist_sp(L s, P p) {
  P r = proj(s, p);
  if (isis_sp(s, r)) return abs(r - p);
  return min(abs(s.a - p), abs(s.b - p));
}

ld dist_ss(L s, L t) {
  if (isis_ss(s, t)) return 0;
  ld a = min(dist_sp(s, t.a), dist_sp(t, s.a));
  ld b = min(dist_sp(s, t.b), dist_sp(t, s.b));
  return min(a, b);
}

int main() {
  while(1) {
    int n;
    cin>>n;
    if(!n) break;
    ld sx,sy,ex,ey;
    cin>>sx>>sy>>ex>>ey;
    L l(sx,sy,ex,ey);
    typedef tuple<ld,ld,ld,ld,ld> box;
    vector<box> bv;
    REP(i,n) {
      int mnx,mny,mxx,mxy,h;
      cin>>mnx>>mny>>mxx>>mxy>>h;
      bv.emplace_back(mnx,mny,mxx,mxy,h);
    }
    ld lb = 0.0, ub = 1000.0;
    REP(i,50) {
      ld mid = (lb + ub) / 2.0;
      bool ok = true;
      REP(j,n) {
        int mnx,mny,mxx,mxy,h;
        tie(mnx,mny,mxx,mxy,h) = bv[j];
        ld r = (h > mid) ? mid : sqrt(mid*mid - (mid-h)*(mid-h));
        vector<L> vl;
        vl.emplace_back(mnx,mny,mxx,mny);
        vl.emplace_back(mnx,mxy,mxx,mxy);
        vl.emplace_back(mnx,mny,mnx,mxy);
        vl.emplace_back(mxx,mny,mxx,mxy);
        REP(k,4)
          if (dist_ss(vl[k], l) < r) ok = false;
        if (max(sx,ex) < mxx && min(sx,ex) > mnx && max(sy,ey) < mxy && min(sy,ey) > mny) ok = false;
      }
      if (ok) lb = mid;
      else ub = mid;
    }
    cout << setprecision(10) << fixed << lb << endl;
  }
  return 0;
}