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


typedef complex<double> P; //Point
typedef pair<P,P> L; //Line, Segment

const double EPS = 1e-10;
const double PI = 6.0 * asin(0.5);

namespace std {
  bool operator < (const P& a, const P& b){
    return fabs(real(a)-real(b)) < EPS ? imag(a) < imag(b) : real(a) < real(b);
  }
}

double dot(P a, P b){ return a.real() * b.real() + a.imag() * b.imag(); }
double cross(P a, P b){ return   a.real() * b.imag() - a.imag() * b.real(); }


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; // c -- a -- b ????????´???
  if(norm(b) < norm(c)) return -2; // a -- b -- c ????????´???
  return 0; // a -- c -- b ????????´????
}

// ????????¨?????????????????????????????????????????????true???
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 );
}


// ????????¨???????????¢
double getDistanceSP(L s, P p){
  if(dot(s.second - s.first, p - s.first) < -EPS) return abs(p - s.first);
  if(dot(s.first - s.second, p - s.second) < -EPS) return abs(p - s.second);
  return abs(cross(s.second - s.first, p - s.first) / abs(s.second - s.first));  //??´?????¨???????????¢
}

// ????????¨??????????????¢
double getDistanceSS(L s1, L s2){
  if(isIntersect(s1,s2)) return 0.0;
  return min( min(getDistanceSP(s1, s2.first), getDistanceSP(s1, s2.second)),
              min(getDistanceSP(s2, s1.first), getDistanceSP(s2, s1.second)));
}

/* 
   ???????§???¢???????????????????????????????§???¢????????¨????¢????????????¨???????????????????????? 
   ????????? 0:?????¨ 1:?¢???? 2:?????¨ 
   ???????¨?????????§????????¨??????????????? 
   O(log n) 
*/
int convex_contains(vector<P> v, P p){ 
  int n = v.size(); 
  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) > 0){ 
      if(cross(v[a]-g, p-g) > 0 && cross(v[c]-g, p-g) < 0) b = c; 
      else a = c; 
    } else { 
      if(cross(v[a]-g, p-g) < 0 && cross(v[c]-g, p-g) > 0) a = c; 
      else b = c; 
    } 
  } 
  b %= n; 
  if(cross(v[a] - p, v[b] - p) < 0) return 0; 
  if(cross(v[a] - p, v[b] - p) > 0) return 2; 
  return 1; 
} 

int N;
L R;
vector<L> S[4];
int H[111];

double getD(L s,int id){
  vector<P> ps;
  for(int j=0;j<4;j++) 
    ps.push_back( S[j][id].first );  
  if( convex_contains( ps, R.first ) | convex_contains( ps, R.second ) ) return 0.0;

  double ret = 1e100;
  for(int i=0;i<4;i++)
    ret = min( ret, getDistanceSS( s, S[i][id] ) );
  return ret;
}

bool check( double h ){
  for(int i=0;i<N;i++){
    double rh = min((double) H[i], h );
    double k;
    if( h < EPS ) k = 0;
    else
      k = cos(asin(rh/h-1.0)) * h;
    //cout << rh << " " << h << " " << k  << " > " << getD(R,i) << endl;
    if( k+EPS > getD(R,i) ) return false; 
  }
  return true;
}

int main(){
  while( cin >> N && N ){
    int sx,sy,ex,ey;
    cin >> sx >> sy >> ex >> ey;
    R = L(P(sx,sy),P(ex,ey));
    for(int i=0;i<4;i++) S[i].clear();
    for(int i=0;i<N;i++){
      int x1,y1,x2,y2;
      cin >> x1 >> y1 >> x2 >> y2 >> H[i];
      S[0].push_back( L( P(x1,y1), P(x2,y1) )  );
      S[1].push_back( L( P(x2,y1), P(x2,y2) )  );
      S[2].push_back( L( P(x2,y2), P(x1,y2) )  );
      S[3].push_back( L( P(x1,y2), P(x1,y1) )  );
    }
    double st = 0.0, ed = 1000.0;
    double res = 0.0;
    while( abs(ed-st) > EPS ){
      double h = (st+ed)/2.0;
      if( check(h) ){
	st = h;
	res = max( res, h );
      }  else
	ed = h;
    }
    printf("%.10lf\n",st);
  }
  
}

Measured memory_bytes: 1328