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

typedef complex<double> P;
typedef pair<P,P> L;

const double INF = 1e+9;
const double EPS = 1e-8;

struct Circle{
  P c;
  double r;

  Circle(P c=P(0,0), double r=0):c(c),r(r){}

  double get_r(double h){
    h = max(r - h, 0.0);
    return sqrt(r*r - h*h);
  }
};

struct rect{
  P p[4];
  double h;
  
  rect(double minx, double miny, double maxx, double maxy, double h):h(h){
    p[0] = P(minx, miny);
    p[1] = P(maxx, miny);
    p[2] = P(maxx, maxy);
    p[3] = P(minx, maxy);
  }
};

struct state{
  P p;
  int pos;
  state(P p, int pos):p(p),pos(pos){}
};

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

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

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) < -EPS) return 2;
  if(norm(b) < norm(c)) return -2;
  return 0;
}

P proj(P p, L l){
    return l.first + dot(p - l.first, l.second - l.first) / norm(l.second - l.first) * (l.second - l.first);
}

bool isIntersectSP(L s, P p){ 
  return abs(s.first-p) + abs(s.second-p) - abs(s.second-s.first) < EPS; 
}

bool isIntersect(L s1, L s2){
  
  //ccw ??????????????????????????¨, ????????????????????´?????????????????¨??????????????????????????????
  if(max(real(s1.first), real(s1.second)) + EPS < min(real(s2.first), real(s2.second)) ||
     max(imag(s1.first), imag(s1.second)) + EPS < min(imag(s2.first), imag(s2.second)) ||
     max(real(s2.first), real(s2.second)) + EPS < min(real(s1.first), real(s1.second)) ||
     max(imag(s2.first), imag(s2.second)) + EPS < min(imag(s1.first), imag(s1.second))) return false;

  return ( ccw(s1.first,s1.second,s2.first) * ccw(s1.first,s1.second,s2.second) <= 0 &&
           ccw(s2.first,s2.second,s1.first) * ccw(s2.first,s2.second,s1.second) <= 0 );
}

enum {OUT, BORDER, IN};
int convex_contains(P v[], int n, P p){ 
  P g = (v[0] + v[n/3] + v[2*n/3]) / 3.0; 
  int a = 0, b = n; 
  while(a + 1 < b){ 
    int c = (a + b) / 2; 
    if(cross(v[a] - g, v[c] - g) > EPS){ 
      if(cross(v[a]-g, p-g) > EPS && cross(v[c]-g, p-g) < -EPS) b = c; 
      else a = c; 
    } else { 
      if(cross(v[a]-g, p-g) < EPS && cross(v[c]-g, p-g) > -EPS) a = c; 
      else b = c; 
    } 
  } 
  b %= n; 
  if(cross(v[a] - p, v[b] - p) < -EPS) return 0; 
  if(cross(v[a] - p, v[b] - p) > EPS) return 2; 
  return 1; 
}

vector<P> getIntersectCS(Circle c, L s){
  vector<P> res;
  P h = proj(c.c, s);
  double d = abs(c.c - h);
  if(d > c.r + EPS);
  else if(d > c.r - EPS){
    if(isIntersectSP(s,h)) res.push_back(h);
  }
  else {
    P v = s.second - s.first;
    v = (sqrt(c.r*c.r - d*d) / abs(v)) * v;
    if(isIntersectSP(s, h+v)) res.push_back(h+v);
    if(isIntersectSP(s, h-v)) res.push_back(h-v);
  }
  return res;
}


int n;
P st, go;
vector<rect> v;
vector<state> pv;

void make_pv(){
  L l = L(st, go);

  pv.clear();
  for(int i=0;i<v.size();i++){
    P ce = v[i].p[0];
    for(int j=0;j<4;j++){
      P res = proj(v[i].p[j], l);
      if(isIntersectSP(l, res)) pv.push_back(state(res, i));      
      if(j > 0) ce += v[i].p[j];
    }    
    ce /= 4.0;

    P res = proj(ce, l);
    if(isIntersectSP(l, res)) {
      pv.push_back(state(res, i));
    }

    pv.push_back(state(st, i));
    pv.push_back(state(go, i));
  }
}

bool isok(double mid){
  for(int i=0;i<pv.size();i++){
    Circle c = Circle(pv[i].p, mid);
    const rect &rec = v[pv[i].pos];
    Circle hc = Circle(c.c, c.get_r(rec.h));
    for(int j=0;j<4;j++){
      L lp = L(rec.p[j], rec.p[(j+1)%4]);
      if(getIntersectCS(hc, lp).size() >= 1 || abs(hc.c - rec.p[j]) < hc.r + EPS){
        return false;
      }
    }
  }
  return true;
}

double solve(){
  double le = 0.0, ri = INF, mid;

  for(int i=0;i<n;i++){
    if(convex_contains(v[i].p, 4, st) != OUT || convex_contains(v[i].p, 4, go) != OUT){
      return 0.0;
    }
    for(int j=0;j<4;j++){
      if(isIntersect(L(st, go), L(v[i].p[j], v[i].p[(j+1)%4]))){
        return 0.0;
      }
    }
  }

  make_pv();

  while(ri - le > EPS){
    mid = (le + ri) / 2.0;
    if(isok(mid)) le = mid;
    else ri = mid;
  }

  return (le + ri) / 2.0;
}

int main(){
  double x1, y1, x2, y2, h;
  while(cin >> n && n){
    v.clear();
    cin >> x1 >> y1 >> x2 >> y2;
    st = P(x1, y1);
    go = P(x2, y2);
    for(int i=0;i<n;i++){
      cin >> x1 >> y1 >> x2 >> y2 >> h;
      v.push_back(rect(x1, y1, x2, y2, h));      
    }
    printf("%.7f\n", solve());
  }
}

Measured memory_bytes: 1308