#include <iostream>
#include <cmath>
#include <algorithm>
#include <cstdio>

#define EPS (1.0e-10)
#define equal(a, b) (fabs((a) - (b)) < EPS)
using namespace std;


class Point {
public:
  double x, y;
  Point(double x = 0, double y = 0) : x(x), y(y) {}
  Point operator - (Point p) { return Point(x - p.x, y - p.y); }
};

typedef Point Vector;

class Segment {
public:
  Point p1, p2;
};

typedef Segment Line;


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;
}

#define COUNTER_CLOCKWISE 1
#define CLOCKWISE -1
#define ONLINE_BACK 2
#define ONLINE_FRONT -2
#define ON_SEGMENT 0

int ccw(Point p0, Point p1, Point p2) {
  Vector a = p1 - p0;
  Vector b = p2 - p0;
  if(cross(a, b) > EPS) return COUNTER_CLOCKWISE;
  if(cross(a, b) < -EPS) return CLOCKWISE;
  if(dot(a, b) < -EPS) return ONLINE_BACK;
  if(norm(a) < norm(b)) return ONLINE_FRONT;
  return ON_SEGMENT;
}

bool isIntersect(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 isIntersect(Segment s1, Segment s2) {
  return isIntersect(s1.p1, s1.p2, s2.p1, s2.p2);
}

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

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

double getDistance(Segment s1, Segment s2) {
  if(isIntersect(s1, s2)) return 0.0;
  return min(min(getDistanceSP(s1, s2.p1), getDistanceSP(s1, s2.p2)),
	     min(getDistanceSP(s2, s1.p1), getDistanceSP(s2, s1.p2)));
}

typedef Segment Rect;
Segment course;
Rect block;
double h;

double getRadius() {
  double radius = 99999999;
  Segment s[4];

  if(block.p1.x < course.p1.x && block.p1.y < course.p1.y &&
     block.p1.x < course.p2.x && block.p1.y < course.p2.y &&
     block.p2.x > course.p1.x && block.p2.y > course.p1.y &&
     block.p2.x > course.p2.x && block.p2.y > course.p2.y ) {
    return 0.0;
  }

  s[0].p1 = Point(block.p1.x, block.p1.y);
  s[0].p2 = Point(block.p2.x, block.p1.y);
  s[1].p1 = Point(block.p1.x, block.p1.y);
  s[1].p2 = Point(block.p1.x, block.p2.y);
  s[2].p1 = Point(block.p1.x, block.p2.y);
  s[2].p2 = Point(block.p2.x, block.p2.y);
  s[3].p1 = Point(block.p2.x, block.p1.y);
  s[3].p2 = Point(block.p2.x, block.p2.y);
  for(int i = 0; i < 4; ++i) {
    double d;
    if(dot(course.p2 - course.p1, s[i].p1 - course.p1) < -EPS && 
       dot(course.p2 - course.p1, s[i].p2 - course.p1) < -EPS ) {
      d = getDistanceSP(s[i], course.p1);
    } else if(dot(course.p1 - course.p2, s[i].p1 - course.p2) < -EPS && 
	      dot(course.p1 - course.p2, s[i].p2 - course.p2) < -EPS ) {
      d = getDistanceSP(s[i], course.p2);
    } else {
      d = getDistance(course, s[i]);
    }
    if(d <= h) radius = min(radius, d);
    else       radius = min(radius, (d*d+h*h)/(2*h));
  }
  return radius;
}

main() {
  int N;
  double maxR;

  while((cin >> N) && N) {
    maxR = 99999999;
    cin >> course.p1.x >> course.p1.y >> course.p2.x >> course.p2.y;
    for(int i = 0; i < N; ++i) {
      cin >> block.p1.x >> block.p1.y >> block.p2.x >> block.p2.y >> h;
      maxR = min(maxR, getRadius());
    }
    cout <<  maxR << endl;
  }
}

Measured memory_bytes: 0