#include <iostream>
#include <cstdio>
#include <vector>
#include <complex>
#include <cmath>
#include <algorithm>
using namespace std;

// * XY座標
#define X real()
#define Y imag()

// * 点の表現
typedef complex<double> P;

// * 許容する誤差ε
const double EPS = 1e-10;
// * Infinity
const double INF = 1e12;
// * 円周率
const double PI = acos(-1.0);
// * Infinity 2
const P INF_P(INF,INF);

// * complex<double> の順序を定義する
namespace std {
	bool operator < (const P& a, const P& b) {
		return (real(a) != real(b))? real(a) < real(b) : imag(a) < imag(b);
	}
}

// * 点座標のデバッグ出力
void print(P p) {
	cout << "point" << p << ";" << endl;
}

// * 2乗する
double sq(double x) {
	return x * x;
}

// * 2点間の距離
double dist(P p1, P p2) {
	return abs(p1 - p2);
}

// * 2つのスカラーが等しいかどうか
bool equal(double a, double b) {
	return ( fabs( a - b ) < EPS );
}
// * 2つのベクトルが等しいかどうか
bool eq_v(P a, P b) {
	return ( equal( a.X, b.X ) && equal( a.Y, b.Y ) );
}

// ベクトルaの単位ベクトルを求める
P unit(P a) {
	return a / abs(a);
}

// ベクトルaの法線ベクトルを求める
vector<P> normal(P a) {
	vector<P> vp;
	vp.push_back( a * P(0,  1) );
	vp.push_back( a * P(0, -1) );
	return vp;
}

// ベクトル a の単位法線ベクトルを求める
vector<P> normal_unit(P a) {
	vector<P> vp;
	vp.push_back( (a * P(0,  1)) / abs(a) );
	vp.push_back( (a * P(0, -1)) / abs(a) ) ;
	return vp;
}

// * 内積 (dot product) : a・b = |a||b|cosΘ
double dot(P a, P b) {
	return real( conj(a) * b );
}

// * 外積 (cross product) : a×b = |a||b|sinΘ
double cross(P a, P b) {
	return imag( conj(a) * b ) ;
}

// 原点を軸に点 p を角度 a (ラジアン)だけ回転させた点を返す
P rot(P p, double a){
	double x = p.X * cos(a) - p.Y * sin(a);
	double y = p.X * sin(a) + p.Y * cos(a);
	return P(x,y);
}

// 点 a を軸に点 b を角度 a (ラジアン)だけ回転させた点を返す
P rot2(P a, P b, double angle){
	P p = b - a;
	return rot( p , angle ) + a;
}

// CCW : 反時計回り (Counter Clock Wise)
// CW : 時計回り (Clock Wise)
enum {CCW=1, CW=-1, ON=0};
// * 3点がどちら回りであるか返す, 3点が1直線に乗っているときは ON を返す
int ccw(const P &a, P b, P c) {
	b-=a, c-=a;
	double rotdir = cross(b,c);
	if( rotdir >  EPS ) return CCW;
	if( rotdir < -EPS ) return CW;
	return ON;
}


// 線分の表現
struct Segment{
	// 点 a, b を端点とする線分
	P a, b;
	// コンストラクタで初期化
	Segment(P a_, P b_) {
		// x 座標の小さいほうの点を 点 a とする. (不要なときはこの1行を削除すること!!!)
		if( b_ < a_ ) swap(a_,b_);
		a = a_; b = b_;
	}
	// 線分の長さを返す
	double length() { return abs(a-b); }
	// 中点を返す
	P mid() { return P( (a.X+b.X)/2.0 , (a.Y+b.Y)/2.0 ); }
	// 点 p が線分上にあるかどうか
	bool contain(P p) { return (abs(a-p) + abs(p-b) < abs(a-b) + EPS); }
	// 線分と点 p の距離
	double distance(P p) {
		if( dot(b-a, p-a) < EPS ) return abs(p-a);
		if( dot(a-b, p-b) < EPS ) return abs(p-b);
		return abs(cross(b-a, p-a)) / abs(b-a);
	}
	// 線分の交差判定
	bool is_intersection(const Segment& s) {
		return ( cross(b-a, s.a-a) * cross(b-a, s.b-a) < EPS ) &&
			   ( cross(s.b-s.a, a-s.a) * cross(s.b-s.a, b-s.a) < EPS );
	}
	// 線分の交差判定と交点計算
	bool intersection(Segment s, P& p) {
		bool result = is_intersection( s );
		if( result ) {
			double d1 = abs( cross(s.b-s.a, a-s.a) );
			double d2 = abs( cross(s.b-s.a, b-s.a) );
			
			if( abs(d1) < EPS && abs(d2) < EPS ) { // 2つの線分が同じ直線上にあるとき
				if( this->contain(s.a) ) {
					p = s.a;
				}else if( this->contain(s.b) ) {
					p = s.b;
				}else if( s.contain( a ) ) {
					p = a;
				}else if( s.contain( b ) ) {
					p = b;
				}else {
					p = INF_P;
				}
			}else if( abs(d1) < EPS ) {
				p = INF_P;
			}else {
				double t = d1 / (d1 + d2);
				p = a + (b-a) * t;
			}
		}else{
			p = INF_P;
		}
		return result;
	}
	// 線分と線分の距離
	double distance(Segment s) {
		if( this->is_intersection( s ) ) { // 交差するとき	
			double d1 = abs( cross(s.b-s.a, a-s.a) );
			double d2 = abs( cross(s.b-s.a, b-s.a) );
			
			if( abs(d1) < EPS && abs(d2) < EPS ) { // 2つの線分が同じ直線上にあるとき
				if( this->contain(s.a) || this->contain(s.b) ) {
					return 0.0;
				}else if( s.contain( a ) || s.contain( b ) ) {
					return 0.0;
				}
			}else{
				return 0.0;
			}
		}
		double A = this->distance(s.a);
		double B = this->distance(s.b);
		double C = s.distance( (*this).a );
		double D = s.distance( (*this).b );
		return min( min(A,B) , min(C,D) );
	}
	// デバッグ出力
	void print() { printf("line(%f,%f,%f,%f); \n", a.X, a.Y, b.X, b.Y ); }
};
// Segment の順序を定義 (x座標の小さい端点で比較)
bool operator < (const Segment& s1, const Segment& s2) { return s1.a < s2.a; }

// 直線の表現 ((*this)[0]) と ((*this)[1]) を通る直線
struct Line : public vector<P> {
	Line(const P &a, const P &b) {
		push_back(a); push_back(b);
	}
	Line(vector<P> v){
		push_back(v[0]); push_back(v[1]);
	}
	Line(){}
	// 2直線の直交判定
	bool orthogonal(const Line& l) {
		return equal( dot( (*this)[0] - (*this)[1] , l[0] - l[1] ) , 0.0 );
	}
	// 2直線の平行判定
	bool parallel(const Line& l) {
		return equal( cross( (*this)[0] - (*this)[1] , l[0] - l[1] ), 0.0 );
	}
	// 点 p が直線上に乗っているか
	bool contain(P p) {
		return equal( cross( (*this)[1] - (*this)[0] , p - (*this)[0] ) , 0.0 );
	}
	// 直線と点 p の距離
	double distance(P a) {
		P p1 = (*this)[0];
		P p2 = (*this)[1];
		return abs( cross( p2 - p1 , a - p1) ) / abs(p2 - p1);
	}
	// 点 (*this)[0] から 点 (*this)[1] への角度を返す [0,2π]
	double get_dir() {
		P p = (*this)[0] - (*this)[1];
		double angle = atan2( p.Y , p.X );
		if( p.X < 0 ) angle += PI;
		if( angle < 0 ) angle += 2.0 * PI;
		return angle;
	}
	// 直線の交差判定
	bool is_intersection(const Line& l) {
		return !equal( cross( (*this)[0] - (*this)[1], l[0] - l[1] ) , 0.0 );
	}
	// 直線の交差判定と交点計算
	bool intersection(Line l, P& p) {
		bool result = this->is_intersection( l );
		if( result ) {
			P a = (*this)[1] - (*this)[0];
			P b = l[1] - l[0];
			p = (*this)[0] + a * cross(b, l[0] - (*this)[0]) / cross(b, a);
		}else {
			p = INF_P;
		}
		return result;
	}
	
	// デバッグ出力
	void print() {
		P p1 = (*this)[0];
		P p2 = (*this)[1];
		double dx = p1.X - p2.X;
		double dy = p1.Y - p2.Y;
		::print( p1 );
		::print( p2 );
		p1.X += 100 * dx;
		p1.Y += 100 * dy;
		p2.X -= 100 * dx;
		p2.Y -= 100 * dy;
		Segment s( p1 , p2 );
		s.print();
	}
};

// 円の表現
struct Circle{
	// 円の中心
	P p;
	// 円の半径
	double r;
	// コンストラクタで初期化
	Circle(P p_, double r_) { p = p_; r = r_; }
	// 円の面積
	double get_area() { return r * r * PI; }
	// 円周
	double circumference() { return 2.0 * r * PI; }
	// 点 a が円の内部にあるかどうか
	bool is_inside(P a) { return ( dist(a,p) <= r ); }
	// 点 a が円周上にあるかどうか
	bool on_boundary(P a) { return equal( dist(a,p) , r ); }
	
	// 直線と円の距離 (円の中心の点と直線の距離 - 円の半径)
	double distance(Line l){
		return l.distance( p ) - r;
	}
	// 等しいかどうか
	bool operator==(const Circle& c) { return (p == c.p && r == c.r) ; };
	// 2つの円の位置関係
	// 2 つの円が離れている => 0
	// 2 つの円が外接する   => 1
	// 2 つの円が交わる     => 2
	// 2 つの円が内接する    => 3 (2つの円が等しいときは内接)
	// 円が含まれている       => 4
	int is_pos(const Circle& c) {
		double d = abs(p - c.p);
		if( r + c.r + EPS < d ) { // 離れている
			return 0;
		}else if( equal( r + c.r , d ) ) { // 外接する
			return 1;
		}else if( equal( fabs(r-c.r) , d ) ) { // 内接する
			return 3;
		}else if( d < fabs(r-c.r) ) { // 含まれる
			return 4;
		}else { // 交わる	
			return 2;
		}
	}
	// 円と直線の交わる点を返す
	pair<P,P> intersection(Line l) {
		pair<P,P> pp;
		if( this->distance(l) > EPS ) { // 円と直線の交点がないとき	
			pp.first = pp.second = INF_P;
		}else { // 円と直線の交点があるとき
			double d = l.distance( p );
			double angle = -l.get_dir();
			// 点 l[0] を軸に点 l[1] と円の中心を回転
			P lp = rot2( l[0] , l[1] , angle );
			P cp = rot2( l[0] , p    , angle );
			double x1 = cp.X - sqrt( sq(r) - sq(d) );
			double x2 = cp.X + sqrt( sq(r) - sq(d) );
			P p1(x1,l[0].Y);
			P p2(x2,l[0].Y);
			// 回転して元に戻す
			p1 = rot2( l[0] , p1 , -angle );
			p2 = rot2( l[0] , p2 , -angle );
			pp.first = p1;
			pp.second = p2;
		}
		return pp;
	}
	// デバッグ出力
	void print() { printf("circle(%f,%f,%f); \n", p.X, p.Y, r ); }
};

struct Rect{
	int x1, y1, x2, y2, h;
	Rect(int x1_, int y1_, int x2_, int y2_, int h_){
		x1 = x1_; y1 = y1_; x2 = x2_; y2 = y2_; h = h_;
	};
};

int main(){
	int n;
	while( cin >> n , n ){
		int sx, sy, ex, ey;
		double ans = 0;
		cin >> sx >> sy >> ex >> ey;
		Segment s( P(sx,sy) , P(ex,ey) );
		
		vector<Rect> v;
		vector<Segment> vs;
		bool NA_flag = false;
		for(int i=0 ; i < n ; i++ ){
			int min_x, min_y, max_x, max_y, h;
			cin >> min_x >> min_y >> max_x >> max_y >> h;
			
			// p1, p2, p3, p4 は i 番目の長方形の座標を表す.
			P p1(min_x,min_y), p2(min_x,max_y), p3(max_x,min_y), p4(max_x,max_y);
			// s1, s2, s3, s4 は i 番目の長方形の辺(=線分)を表す.
			Segment s1(p1,p2), s2(p1,p3), s3(p2,p4), s4(p3,p4);
			// スタートからゴールまでの線分と交差する長方形があるかどうか調べる
			if( s.is_intersection(s1) || s.is_intersection(s2) ){
				NA_flag = true;
			}else if( s.is_intersection(s1) || s.is_intersection(s2) ){
				NA_flag = true;
			}else if( min_x <= sx && sx <= max_x && min_y <= sy && sy <= max_y ){
				NA_flag = true;
			}else if( min_x <= ex && ex <= max_x && min_y <= ey && ey <= max_y ){
				NA_flag = true;
			}
			
			// d は 長方形と線分 s との距離
			double d = min( s.distance(p1) , s.distance(p2) );
			d = min( d , min( s.distance(p3) , s.distance(p4) ) );
			d = min( d , min( s.distance(s1) , s.distance(s2) ) );
			d = min( d , min( s.distance(s3) , s.distance(s4) ) );
			
			// 真横からみた座標に 辺の追加
			vs.push_back( Segment( P(d,0) , P(d,h) ) );
			
			v.push_back( Rect( min_x, min_y, max_x, max_y, h ) );
		}
		if( NA_flag ){
			cout << 0 << endl;
		}else{
			double low=0.0, high=1000.0,mid=500.0;
			// 適当に二分探索
			for(int i=0 ; i < 100 ; i++ ){
				mid = (low+high) / 2.0;
				Circle c( P(0,mid) , mid );
				bool flag = false;
				for(int i=0 ; i < vs.size() ; i++ ){
					Line l( vs[i].a , vs[i].b );
					pair<P,P> pp = c.intersection( l );
					
					if( pp.first == INF_P || pp.first == pp.second ){ // 交差しない
					}else{
						P p1 = pp.first;
						P p2 = pp.second;
						// 円と線分が交差するとき
						if( vs[i].contain(p1) || vs[i].contain(p2) ){
							flag = true;
						}
					}
				}
				
				if( flag ){ // 交差するとき
					high = mid;
				}else{ // 交差しないとき
					low = mid;
				}
			}
			ans = mid;
			// cout << ans << endl;
			printf("%.6f\n", ans);
		}
	}
}

Measured memory_bytes: 1040