#include <iostream>
#include <cstdio>
#include <vector>
#include <queue>
#include <string>
#include <cmath>
#include <set>
#include <map>
#include <algorithm>
#include <sstream>
#include <complex>
#include <limits.h>

using namespace std;

#define vec vector
#define pb push_back
#define FOR(i,c) for(__typeof((c).begin())i=(c).begin();i!=(c).end();++i)
#define REP(i,n) for(int i=0; i<(int)(n); i++)
#define REPD(i,n) for(int i=(int)(n); i-->0;)
#define REPI(i,a,b) for(int i=(int)(a); i<=(int)(b); i++)
#define ALL(a) (a).begin(),(a).end()
#define mp make_pair
#define fst first
#define snd second

#define INFTY 1000000000
#define EPS 1e-9
#define PI 3.141592653589793

#define INF (INFTY/3)

#define rev(s) (string((s).rbegin(), (s).rend()))

typedef long long Int;

typedef vector<int> vi;
typedef vector<vi> vvi;
typedef pair<int,int> pii;
typedef vector<double> vd;
typedef vector<vd> vvd;
typedef pair<double,double> pdd;

void debug(vi v){ REP(i,v.size()) cout<<v[i]<<" "; cout<<endl; }

int nextInt(){ int t; cin>>t; return t; }

#define ZEROP(x) (fabs(x) < EPS)
#define EQ(x, y) ZEROP((x) - (y))
#define LT(x, y) ((x) - (y) <= -EPS) // x < y
#define LE(x, y) ((x) - (y) < +EPS) // x <= y
#define SIGN(x) ((x)<-EPS?-1:((x)>EPS?+1:0))

typedef complex<double> P;
#define EQV(a,b) ( EQ((a).real(), (b).real()) && EQ((a).imag(), (b).imag()) )

namespace std {
   bool operator < (const P& a, const P& b) {
     return real(a) != real(b) ? real(a) < real(b) : imag(a) < imag(b);
   }
}
double cross(const P& a, const P& b) {
   return imag(conj(a)*b); 
} 
double dot(const P& a, const P& b) {
   return real(conj(a)*b); 
}  
struct L : public vector<P> {
  L() {}
  L(const P &a, const P &b) {
    push_back(a); push_back(b);
  } 
};  
typedef vector<P> G;  
struct C {
   P p; double r;
   C(const P &p, double r) : p(p), r(r) { }
}; 


#define MAXN 50
int N;
L sl; // start line
int minx[MAXN];
int miny[MAXN];
int maxx[MAXN];
int maxy[MAXN];
int h[MAXN];

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


bool intersectSS(const L &s, const 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;
}
bool intersectSP(const L &s, const P &p) {
  return abs(s[0]-p)+abs(s[1]-p)-abs(s[1]-s[0]) < EPS; // triangle inequality
}


P projection(const L &l, const P &p) {
  double t = dot(p-l[0], l[0]-l[1]) / norm(l[0]-l[1]);
  return l[0] + t*(l[0]-l[1]);
}


double distanceSP(const L &s, const P &p) {
  const P r = projection(s, p);
  if (intersectSP(s, r)) return abs(r - p);
  return min(abs(s[0] - p), abs(s[1] - p));
}

// USE IN THIS PROBLEM
double distanceSS(const L &s, const L &t) {
  if (intersectSS(s, t)) return 0;
  return min(min(distanceSP(s, t[0]), distanceSP(s, t[1])),
             min(distanceSP(t, s[0]), distanceSP(t, s[1])));
}

bool covered(int sx,int sy,int ex,int ey,int ax,int ay,int bx,int by) {
  return (ax <= sx && sx <= bx && ay <= sy && sy <= by) ||
    (ax <= ex && ex <= bx && ay <= ey && ey <= by);
}


double solve() {
  double r = INT_MAX;
  REP(i,N) {
    L l[]={L(P(minx[i],miny[i]),P(maxx[i],miny[i])),
	   L(P(maxx[i],miny[i]),P(maxx[i],maxy[i])),
	   L(P(maxx[i],maxy[i]),P(minx[i],maxy[i])),
	   L(P(minx[i],maxy[i]),P(minx[i],miny[i]))};
    double mind = INT_MAX;
    int mini; //min index
    if(covered(real(sl[0]),imag(sl[0]),real(sl[1]),imag(sl[1]),
	       minx[i],miny[i],maxx[i],maxy[i])) return 0.0;
    REP(j,4) {
      if(intersectSS(l[j],sl)) return 0.0;
      double dd = distanceSS(l[j],sl);
      if(LT(dd,mind)) {
	mind = dd;
	mini = j;
      }
    }
    double r2;
    //printf("mind=%lf\n",mind);
    if(LE(mind,h[i])) { // mind <= h[i]
      r2=mind;
    } else {
      r2=(h[i]*h[i] + mind*mind) / (2*h[i]);
    }
    r=min(r,r2);
    //printf("r=%lf\n",r);
  }
  return r;
}
	
main() {
  while(cin>>N,N) {
    int sx,sy,ex,ey;
    cin>>sx>>sy>>ex>>ey;
    sl = L(P(sx,sy),P(ex,ey));
    REP(i,N)
      cin>>minx[i]>>miny[i]>>maxx[i]>>maxy[i]>>h[i];
    printf("%.4lf\n",solve());
  }
}

Measured memory_bytes: 0