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

using pii = pair<int,int>;
using ll = long long;
#define rep(i, j) for(int i=0; i < (int)(j); i++)
#define repeat(i, j, k) for(int i = (j); i < (int)(k); i++)
#define all(v) v.begin(),v.end()
#define debug(x) cerr << #x << " : " << x << endl

template<class T> bool set_min(T &a, const T &b) { return a > b  ? a = b, true : false; }
template<class T> bool set_max(T &a, const T &b) { return a < b  ? a = b, true : false; }
// vector
template<class T> istream& operator >> (istream &is , vector<T> &v) { for(T &a : v) is >> a; return is; }
template<class T> ostream& operator << (ostream &os , const vector<T> &v) { for(const T &t : v) os << "\t" << t; return os << endl; }

const int INF = 1 << 30;
const ll INFL = 1LL << 60;
const double EPS = 1e-8;


template<class T> bool eq(T a, T b) { return abs(a - b) < EPS; }
// point ??? complex<double> ??§???????????????????????????
#define CPR const Point&
struct Point {
    using T = double;    
    T x, y;
    Point() {}
    Point(T x, T y):x(x), y(y) {}
    bool operator == (CPR p) const { return eq(x, p.x) and eq(y, p.y); }
    bool operator != (CPR p) const { return !(*this == p); }    
    Point operator + (CPR p) const { return Point(x + p.x, y + p.y); }
    Point operator - (CPR p) const { return *this + (-p); }
    // x, y ???
    bool operator <  (CPR p) const { return !eq(x, p.x) ? x < p.x : y < p.y; }
    bool operator >  (CPR p) const { return !eq(x, p.x) ? x > p.x : y > p.y; }
    Point operator - () const { return Point(-x, -y); }
    Point operator * (T k) const { return Point(x * k, y * k); }
    Point operator / (T k) const { return Point(x / k, y / k); }
    friend istream &operator >> (istream& is, Point& p) { return is >> p.x >> p.y;}
    friend ostream &operator << (ostream& os, CPR p) { return os << "(" << p.x << "," << p.y << ")";}
};
double dot(CPR a, CPR b) { return a.x * b.x + a.y * b.y; }
double cross(CPR a, CPR b) { return a.x * b.y - a.y * b.x; }
double length2(CPR p) { return p.x * p.x + p.y * p.y; }
double length(CPR p) { return sqrt(length2(p)); }
double distance(CPR a, CPR b) { return length(a - b); }
Point unit(CPR p) { return p / length(p); }

enum ccw_t {
    COUNTER_CLOCK_WISE = 1,
    CLOCK_WISE = -1,
    STRAIGHT_C_A_B = 2,
    STRAIGHT_A_B_C = -2,
    STRAIGHT_A_C_B = 0
};

ccw_t ccw(CPR a, CPR b, CPR c){
    Point ab = b - a, ac = c - a;
    if( cross(ab,ac) > EPS ) return COUNTER_CLOCK_WISE; // +1 a-b-c ???????¨???????
    if( cross(ab,ac) < -EPS ) return CLOCK_WISE;        // -1 a-b-c ????¨???????
    if( dot(ab,ac) < -EPS ) return STRAIGHT_C_A_B;      // +2 c-a-b
    if( length2(ab) < length2(ac) )return STRAIGHT_A_B_C;     // -2 a-b-c or a==b
    return STRAIGHT_A_C_B;                              //  0 a-c-b or b==c or a==c
}

#define CSR const Segment&
struct Segment {
    Point a, b;
    Segment(){}
    Segment(const Point& a, const Point& b):a(a), b(b){}
    pair<Point,Point> to_pair() const { return make_pair(a,b); }
    bool operator == (CSR s) const { return to_pair() == s.to_pair();}
    bool operator != (CSR s) const { return !(*this == s); }
    friend istream &operator >> (istream& is, Segment &s){ return is >> s.a >> s.b;}
    friend ostream &operator << (ostream& os, CSR s) { return os << s.a << "->" << s.b;}
};
double length(CSR s) {
    return distance(s.a, s.b);
}
bool contain(CSR s, CPR p) {
    return ccw(s.a, s.b, p) == 0; // STRAIGHT_A_C_B;
}
Point projection(CSR s, CPR p) {
    Point v = s.b - s.a;
    double t = dot(p - s.a, v) / length2(v); // ??????
    return v * t + s.a;
}
Point closest_point(CSR s, CPR p) {
    Point pp = projection(s, p);
    return contain(s, pp) ? pp : distance(s.a, p) < distance(s.b, p) ? s.a : s.b;
}
double distance(CSR s, CPR p) {
    if( dot(s.b - s.a ,p - s.a) < EPS ) return distance(p, s.a);
    if( dot(s.a - s.b ,p - s.b) < EPS ) return distance(p, s.b);
    return abs(cross(s.b - s.a, p - s.a) / length(s));
}
bool intersect(CSR s, CSR t) { // ????????????
    return ccw(s.a, s.b, t.a) * ccw(s.a, s.b, t.b) <= 0 and ccw(t.a, t.b, s.a) * ccw(t.a, t.b, s.b) <= 0;
}


struct Rectangle {
    array<Point, 4> p;
    // order:
    //     3 2
    //     0 1
    Rectangle(const array<Point, 4> &pp):p(pp) {
        // ????????????????????????????????????
        rep(i, 3) repeat(j, i + 1, 4) {
            int cnt = 0;
            rep(k, 4) if(k != i and k != j){
                cnt += ccw(p[i], p[j], p[k]) == COUNTER_CLOCK_WISE;
            }
            if(cnt == 2) {
                swap(p[i + 1], p[j]);
                break;
            }
        } 
    }
    bool intersect(CSR s) {
        bool res = false;
        rep(i, 4) res |= ::intersect(s, Segment(p[i], p[(i + 1) % 4]));
        return res;
    }
    bool contain(CPR pp) {
        bool flg = true;
        rep(i, 4) flg &= ccw(p[i], p[(i + 1) % 4], pp) == COUNTER_CLOCK_WISE;
        return flg;
    }
    bool contain(CSR s) {
        return contain(s.a) and contain(s.b);
    }
    Point closest_point(CPR pp) {
        Point res = p[0];
        rep(i, 4) {
            Point ppp = ::closest_point(Segment(p[i], p[(i+1)%4]), pp);
            if(distance(res, pp) > distance(ppp, pp)) res = ppp;
        }
        return res;
    }
    Point closest_point(CSR s) {
        Point res = p[0];
        repeat(i, 1, 4) if(distance(s, res) > distance(s, p[i])) res = p[i];
        for(Point pp : {s.a, s.b}) {
            Point ppp = closest_point(pp);
            if(distance(s, res) > distance(s, ppp)) res = ppp;
        }
        return res;
    }
};


class Solver {
  public:
    Segment S;
    vector<Point> minP, maxP;
    vector<double> H;
    bool solve() {

        int N; cin >> N;
        if(not N) return false;
        cin >> S;
        minP.resize(N);
        maxP.resize(N);
        H.resize(N);
        rep(i, N) cin >> minP[i] >> maxP[i] >> H[i];
        
        double max_r = INF;

        rep(i, N) {            
            Rectangle rect({minP[i], maxP[i], Point(minP[i].x, maxP[i].y), Point(maxP[i].x, minP[i].y)});

            if(rect.intersect(S) or rect.contain(S)) {
                cout << 0 << endl;
                return true;
            }

            double d = distance(S, rect.closest_point(S));
            double r = (d * d + H[i] * H[i]) / (2 * H[i]);
            if(r < H[i]) r = d;
            set_min(max_r, r);
        }

        cout << max_r << endl;
        return true;
    }
};

int main() {
    cin.tie(0);
    ios::sync_with_stdio(false);
    while(1) {
        Solver s;
        if(not s.solve()) break;
    }
    return 0;
}

Measured memory_bytes: 3288