#include <iostream>
#include <cstdio>
#include <iomanip>
#include <vector>
#include <map>
#include <set>
#include <queue>
#include <bitset>
#include <stack>
#include <utility>
#include <numeric>
#include <algorithm>
#include <functional>
#include <cctype>
#include <complex>
#include <string>
#include <sstream>
#include <fstream>
#include <cassert>
using namespace std;

//common

typedef int  i32;
typedef long long i64,ll;
typedef long double ld;

#define BR "\n"
#define ALL(c) (c).begin(),(c).end()
#define REP(i,n) for(int i=0;i<(int)(n);++i)
#define FOR(i,l,r) for(int i=(int)l;i<(int)(r);++i)
#define EACH(it,o) for(auto it = (o).begin(); it != (o).end(); ++it)
#define IN(l,v,r) ((l)<=(v) && (v)<(r))

//config
//#define NDEBUG
//#define INF 1<<30
//#define EPS 1e-8
//const ll MOD =100000007;

//debug
#ifdef NDEBUG
#define DUMP(x)
#define DUMPLN(x)
#define DEBUG(x)
#define DEBUGLN(x)
#define LINE()
#define LINELN()
#define CHECK(exp,act)
#define STOP(e)
#else
#define DUMP(x)  cerr << #x << " = " << (x)
#define DUMPLN(x)  DUMP(x) <<endl
#define DEBUG(x) DUMP(x) << LINE() << " " << __FILE__
#define DEBUGLN(x) DEBUG(x)<<endl
#define LINE()    cerr<< " (L" << __LINE__ << ")"
#define LINELN()    LINE()<<endl
#define CHECK(exp,act)  if(exp!=act){DUMPLN(exp);DEBUGLN(act);}
#define STOP(e)  CHECK(e,true);if(!(e)) exit(1);
#endif

template<class T> inline string toString(const vector<T>& x) {
	stringstream ss;
	REP(i,x.size()){
		if(i!=0)ss<<" ";
		ss<< x[i];
	}
	return ss.str();
}

template<class T> inline string toString(const vector<vector<T> >& map) {
	stringstream ss;
	REP(i,map.size()){
		if(i!=0)ss<<BR;
		ss<< toString(map[i]);
	}
	return ss.str();
}
template<class K,class V>  string toString(map<K,V>& x) {
	string res;stringstream ss;
	for(auto& p:x)ss<< p.first<<":" << p.second<<" ";
	return ss.str();
}

string BITtoString(int bit){
    stringstream ss;
    while(bit!=0){ss<<(bit%2);bit/=2;}
    string res=ss.str();reverse(ALL(res));
    return res;
}

template<typename T,typename V> inline T pmod(T v,V MOD){
	return (v%MOD+MOD)%MOD;
}
#define nextInt(n) scanf("%d",&n)
#define defInt(n) int n;nextInt(n)
#define nextLong(n) scanf("%lld",&n)
#define defLong(n) ll n;nextLong(n)
#define nextDouble(n) scanf("%lf",&n)

namespace Ps{
	const double EPS = 1e-8;
	const double INF = 1e12;

	typedef complex<double> P;
	#define X(a) (real(a))
	#define Y(a) (imag(a))
	
	// a×b
	double cross(const P& a,const P& b){
		return imag(conj(a)*b);
	}
	// a・b
	double dot(const P&a,const P& b) {
		return real(conj(a)*b);
	}

	 int ccw(const P& a,P b,P c){
		b -= a; c -= a;
		  if (cross(b,c) > 0)   return +1;       // counter clockwise
		  if (cross(b,c) < 0)   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;
	  }

}
using namespace Ps;

namespace Ls{
	struct L : public vector<P> {
	  L(const P &a, const P &b) {
	    push_back(a); push_back(b);
	  }
	};
	bool isIntersectSS(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 isIntersectSP(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 (isIntersectSP(s, r)) return abs(r - p);
	  return min(abs(s[0] - p), abs(s[1] - p));
	}
	double distanceSS(const L &s, const L &t) {
	  if (isIntersectSS(s, t)) return 0;
	  return min(min(distanceSP(s, t[0]), distanceSP(s, t[1])),
	             min(distanceSP(t, s[0]), distanceSP(t, s[1])));
	}
}
using namespace Ls;

namespace Polys{
	typedef vector<P> Poly,ConvexPoly;
	#define prev(as, i) as[(i-1+as.size())%as.size()]
	#define curr(as, i)  as[i]
	#define next(as, i) as[(i+1)%as.size()]

	// verified by ACAC005 C
	// http://judge.u-aizu.ac.jp/onlinejudge/creview.jsp?rid=899277&cid=ACAC005
	enum { OUT, ON, IN };
	int contains(const Poly& ps, const P& p) {
	  	bool in = false;
	  	REP(i,ps.size()){
			P a = curr(ps,i) - p, b = next(ps,i) - p;
			if (Y(a) > Y(b)) swap(a, b);
			if (Y(a) <= 0 && 0 < Y(b))
	 		if (cross(a, b) < 0) in = !in;
	    		if (cross(a, b) == 0 && dot(a, b) <= 0) return ON;
	  	}
		return in ? IN : OUT;
	}
}

using namespace Polys;

class Main{
	public:

	int N;
	vector<P> ps;
	void run(){
		// ifstream cin("D2");
//		ofstream cout( "D2.out" );
		
		while(true){
			cin >> N;if(N==0)break;
			double sx,sy,ex,ey;cin >> sx >> sy >> ex >> ey;
			L l=L(P(sx,sy),P(ex,ey));
			
			vector<Poly> ps(N,Poly(4));
			vector<double> hs(N);
			REP(i,N){
				double mx,my,Mx,My,h;cin >> mx>>my >> Mx >> My >> h;
				ps[i][0]=P(mx,my);ps[i][1]=P(Mx,my);ps[i][2]=P(Mx,My);ps[i][3]=P(mx,My);
				hs[i]=h;
			}

			double lr=0,rr=1e16;

			//包含チェック
			REP(i,N)if(contains(ps[i],l[0]) || contains(ps[i],l[1]))rr=0;

			while(rr-lr>1e-9){
				double mr=(lr+rr)/2;

				bool ok=true;
				REP(i,N){
					// P
					REP(j,4){
						double d=distanceSP(l,ps[i][j]);
						if(mr<d)continue;
						if(mr-sqrt(mr*mr-d*d)<=hs[i])ok=false;
					}
					// L
					REP(j,4){
						double d=distanceSS(l,L(ps[i][j],ps[i][(j+1)%4]));
						if(mr<d)continue;
						if(mr-sqrt(mr*mr-d*d)<=hs[i])ok=false;
					}
				}
				if(ok)lr=mr;
				else rr=mr;
			}
			cout << lr <<endl;
		}
	}


};
int main(){
	cout <<fixed<<setprecision(15);	
	ios::sync_with_stdio(false);
	Main().run();
	return 0;
}

Measured memory_bytes: 1340