#include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <vector>


#define EPSILON 1e-9


class point_t;


class vector_t {
public:
  double x;
  double y;
  double z;
  
public:
  vector_t(double x = 0, double y = 0, double z = 0) : x(x), y(y), z(z) {};
  
  vector_t(const point_t& p);
  
public:
  vector_t operator-() const {
    return vector_t(-x, -y, -z);
  };
  
  double operator*(const vector_t& v) const {
    return x * v.x + y * v.y + z * v.z;
  };
  
  vector_t operator*(double a) const {
    return vector_t(x * a, y * a, z * a);
  };
  
  vector_t operator/(double a) const {
    return vector_t(x / a, y / a, z / a);
  };
  
  vector_t operator^(const vector_t& v) const {
    return vector_t(y * v.z - z * v.y,
                    z * v.x - x * v.z,
                    x * v.y - y * v.x);
  };
    
  vector_t operator-=(const vector_t& v) {
    x -= v.x;
    y -= v.y;
    z -= v.z;
    
    return *this;
  };

public:
  double length() const {
    return sqrt(*this * *this);
  };

  vector_t normal() const {
    return *this / length();
  };
};


class point_t {
public:
  double x;
  double y;
  double z;
  double w;

public:
  point_t(double x = 0, double y = 0, double z = 0, double w = 1) : x(x), y(y), z(z), w(w) {};
  
public:
  point_t operator+(const vector_t& v) const {
    return point_t(x + v.x, y + v.y, z + v.z);
  };

  vector_t operator-(const point_t& p) const {
    return vector_t(x - p.x, y - p.y, z - p.z);
  };
};


vector_t::vector_t(const point_t& p) : x(p.x / p.w), y(p.y / p.w), z(p.z / p.w)
{
}


class point_point_squared_distance : public std::unary_function<point_t, double>
{
public:
  point_point_squared_distance(const point_t& p) : p_(p)
  {
  };

public:
  double operator()(const point_t& p) const {
    vector_t v(p - p_);

    return v * v;
  };

private:
  point_t p_;
};


class point_segment_squared_distance : public std::unary_function<point_t, double> {
public:
  point_segment_squared_distance(const point_t& p0, const point_t& p1) :
    p0_(p0), a_(p1 - p0)
  {
    aa_ = a_ * a_;
  };

public:
  double operator()(const point_t& p) const {
    vector_t b(p - p0_);

    double dot = (a_ * b) / aa_;

    if (dot < 0) {
      return b * b;
    }
    else if (dot > 1) {
      b -= a_;

      return b * b;
    }
    else {
      vector_t area(a_ ^ b);

      return area * area / aa_;
    }
  };

private:
  point_t p0_;

  vector_t a_;

  double aa_;
};


class segment_segment_squared_distance : public std::binary_function<point_t, point_t, double>
{
public:
  segment_segment_squared_distance(const point_t& p0, const point_t& p1) :
    p0_(p0), p1_(p1), fn_(p0, p1)
  {
  };

public:
  double operator()(const point_t& p2, const point_t& p3) const {
    point_segment_squared_distance fn(p2, p3);

    double d;

    d = std::min(fn_(p2),  fn_(p3));
    d = std::min(fn (p0_), d); 
    d = std::min(fn (p1_), d); 

    return d;
  };

private:
  point_t p0_;
  point_t p1_;

  point_segment_squared_distance fn_;
};

class segment_segment_distance : public std::binary_function<point_t, point_t, double>
{
public:
  segment_segment_distance(const point_t& p0, const point_t& p1) : fn_(p0, p1)
  {
  };

public:
  double operator()(const point_t& p2, const point_t& p3) const {
    return sqrt(fn_(p2, p3));
  };

private:
  segment_segment_squared_distance fn_;
};


class segment_segment_intersect : public std::binary_function<point_t, point_t, bool>
{
public:
  segment_segment_intersect(const point_t& p0, const point_t& p1) : p0_(p0), p1_(p1)
  {
  };

public:
  bool operator()(const point_t& p2, const point_t& p3) {
    bool a = (((p1_ - p0_) ^ (p2  - p0_)).z > -EPSILON);
    bool b = (((p1_ - p0_) ^ (p3  - p0_)).z > -EPSILON);
    bool c = (((p3  - p2 ) ^ (p0_ - p2 )).z > -EPSILON);
    bool d = (((p3  - p2 ) ^ (p1_ - 02 )).z > -EPSILON);

    return (a ^ b) && (c ^ d);
  };

private:
  point_t p0_;
  point_t p1_;
};


int main(int argc, char** argv)
{
  while (1) {
    int N;

    std::cin >> N;

    if (N == 0)
      break;

    point_t s, e;

    std::cin >> s.x >> s.y >> e.x >> e.y;

    std::vector<std::pair<point_t, point_t> > segments;
    std::vector<double>                       hs;
    
    for (int i = 0; i < N; i ++) {
      point_t pm, pp;
      double  h;

      std::cin >> pm.x >> pm.y >> pp.x >> pp.y >> h;

      point_t p1(pm.x, pm.y);
      point_t p2(pp.x, pm.y);
      point_t p3(pp.x, pp.y);
      point_t p4(pm.x, pp.y);

      segments.push_back(std::make_pair(p1, p2)); hs.push_back(h);
      segments.push_back(std::make_pair(p2, p3)); hs.push_back(h);
      segments.push_back(std::make_pair(p3, p4)); hs.push_back(h);
      segments.push_back(std::make_pair(p4, p1)); hs.push_back(h);
    }

    segment_segment_intersect fn1(s, e);
    segment_segment_distance  fn2(s, e);

    double l = 0, u = 1111;

    for (int i = 0; i < N * 4; i ++)
      if (fn1(segments[i].first, segments[i].second)) {
        u = 0;

        break;
      }

    while (u - l > 1e-12) {
      double m = (l + u) / 2;

      bool conflict = false;

      for (int i = 0; i < N * 4; i ++) {
        double d = fn2(segments[i].first, segments[i].second);

        if (d < m)
          conflict = (m - sqrt(m * m - d * d) < hs[i]);

        if (conflict)
          break;
      }

      if (conflict) {
        u = m;
      }
      else {
        l = m;
      }
    }

    std::cout << std::setprecision(13) << (l + u) / 2 << std::endl;
  }
    
  return 0;
}

Measured memory_bytes: 1348