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

const int INF = 1e5;

#define EPS (1e-10)
#define equals(a, b) (fabs((a)-(b)) < EPS)
#define PI 3.141592653589793238

static const int CCW_COUNTER_CLOCKWISE = 1;
static const int CCW_CLOCKWISE = -1;
static const int CCW_ONLINE_BACK = 1;
static const int CCW_ONLINE_FRONT = 1;
static const int CCW_ON_SEGMENT = 1;

struct Point {
  double x, y;
  Point() {}  
  Point(double x, double y) :x(x), y(y){}
  Point operator-(Point p) { return Point(x-p.x, y-p.y); }
  double norm() { return x*x+y*y; }
  double abs() { return sqrt(norm()); }
};

typedef Point Vector;

struct Segment {
  Point p1, p2;
  Segment() {}
  Segment(Point p1, Point p2): p1(p1), p2(p2) {}
};

typedef Segment Line;

bool intersectSS(Point p1, Point p2, Point p3, Point p4);
bool intersectSS(Segment s1, Segment s2);

double norm(Vector a) {
  return a.x*a.x+a.y*a.y;  
}

double abs(Vector a) {
  return sqrt(norm(a));
}

double dot(Vector a, Vector b) {
  return a.x*b.x+a.y*b.y;  
}

double cross(Vector a, Vector b) {
  return a.x*b.y-a.y*b.x;  
}

int ccw(Point p0, Point p1, Point p2) {
  Vector a = p1-p0;
  Vector b = p2-p0;
  if ( cross(a, b) > EPS ) return CCW_COUNTER_CLOCKWISE;
  if ( cross(a, b) < -EPS ) return CCW_CLOCKWISE;
  if ( dot(a, b) < -EPS ) return CCW_ONLINE_BACK;
  if ( a.norm() < b.norm() ) return CCW_ONLINE_FRONT;
  return CCW_ON_SEGMENT; 
}

bool intersectSS(Point p1, Point p2, Point p3, Point p4) {
  return (ccw(p1, p2, p3)*ccw(p1, p2, p4) <= 0 &&
	  ccw(p3, p4, p1)*ccw(p3, p4, p2) <= 0 );
}

bool intersectSS(Segment s1, Segment s2) {
  return intersectSS(s1.p1, s1.p2, s2.p1, s2.p2);  
}

double getDistanceLP(Line l, Point p) {
  return abs(cross(l.p2-l.p1, p-l.p1)/abs(l.p2-l.p1));
}

double getDistanceSP(Segment s, Point p) {
  if ( dot(s.p2-s.p1, p-s.p1) < 0.0 ) return abs(p-s.p1);
  if ( dot(s.p1-s.p2, p-s.p2) < 0.0 ) return abs(p-s.p2);
  return getDistanceLP(s, p);  
}

double getDistanceSS(Segment s1, Segment s2) {
  if ( intersectSS(s1, s2) ) return 0.0;  
  return min(min(getDistanceSP(s1, s2.p1), getDistanceSP(s1, s2.p1)),
	     min(getDistanceSP(s2, s1.p1), getDistanceSP(s2, s1.p1)));		 
}

int main() {
  int N;
  while ( cin >> N, N ) {
    Point s, e;
    cin >> s.x >> s.y >> e.x >> e.y;

    vector<double> h(N);
    vector<Point> b1(N), b2(N);    
    for ( int i = 0; i < N; i++ ) {
      cin >> b1[i].x >> b1[i].y >> b2[i].x >> b2[i].y;
      cin >> h[i];      
    }

    double ans = (double)100000.0;
    Segment se(s, e);    
    for ( int i = 0; i < N; i++ ) {
      //cout << ans << endl;
      Point p1 = b1[i], p2(b1[i].x, b2[i].y), p3 = b2[i], p4(b2[i].x, b1[i].y);      
      Segment s1(p1, p2), s2(p2, p3), s3(p3, p4), s4(p4, p1);
      double l = (double)100000.0;
      if ( min(b1[i].x, b2[i].x) <= s.x && s.x <= max(b1[i].x, b2[i].x) &&
	   min(b1[i].y, b2[i].y) <= s.y && s.y <= max(b1[i].y, b2[i].y) ) {
	ans = 0;	
      }
      if ( min(b1[i].x, b2[i].x) <= e.x && e.x <= max(b1[i].x, b2[i].x) &&
	   min(b1[i].y, b2[i].y) <= e.y && e.y <= max(b1[i].y, b2[i].y) ) {
	ans = 0;	
      }
      l = min(l, getDistanceSS(se, s1));
      l = min(l, getDistanceSS(se, s2));
      l = min(l, getDistanceSS(se, s3));
      l = min(l, getDistanceSS(se, s4));
      if ( l <= (double)h[i] ) ans = min(ans, l);
      else ans = min(ans, (l*l+h[i]*h[i])/h[i]/2);      
    }

    cout << fixed << setprecision(10) << ans << endl;  
  }
  
  return 0;
}


Measured memory_bytes: 3264