Language: C++

#include <iostream>
#include <cstdio>
#include <vector>
#include <queue>
#include <string>
#include <cmath>
#include <set>
#include <map>
#include <algorithm>
#include <sstream>
#include <complex>

using namespace std;

#define vec vector
#define pb push_back
#define FOR(i,c) for(__typeof((c).begin())i=(c).begin();i!=(c).end();++i)
#define REP(i,n) for(int i=0; i<(int)(n); i++)
#define REPD(i,n) for(int i=(int)(n); i-->0;)
#define REPI(i,a,b) for(int i=(int)(a); i<=(int)(b); i++)
#define ALL(a) (a).begin(),(a).end()
#define mp make_pair
#define fst first
#define snd second

#define INFTY 1000000000
#define EPS 1e-9
#define PI 3.141592653589793

#define INF (INFTY/3)

#define rev(s) (string((s).rbegin(), (s).rend()))

typedef long long Int;

typedef vector<int> vi;
typedef vector<vi> vvi;
typedef pair<int,int> pii;
typedef vector<double> vd;
typedef vector<vd> vvd;
typedef pair<double,double> pdd;

void debug(vi v){ REP(i,v.size()) cout<<v[i]<<" "; cout<<endl; }

int nextInt(){ int t; cin>>t; return t; }

define ZEROP(x) (fabs(x) < EPS)
#define EQ(x, y) ZEROP((x) - (y))
#define LT(x, y) ((x) - (y) <= -EPS) // x < y
#define LE(x, y) ((x) - (y) < +EPS) // x <= y
#define SIGN(x) ((x)<-EPS?-1:((x)>EPS?+1:0))

typedef complex<double> P;
#define EQV(a,b) ( EQ((a).real(), (b).real()) && EQ((a).imag(), (b).imag()) )

namespace std {
   bool operator < (const P& a, const P& b) {
     return real(a) != real(b) ? real(a) < real(b) : imag(a) < imag(b);
   }
}
double cross(const P& a, const P& b) {
   return imag(conj(a)*b);
} 
double dot(const P& a, const P& b) {
   return real(conj(a)*b); 
}  
struct L : public vector<P> {
  L() {}
  L(const P &a, const P &b) {
    push_back(a); push_back(b);
  } 
};  
typedef vector<P> G;  
struct C {
   P p; double r;
   C(const P &p, double r) : p(p), r(r) { }
}; 


#define MAXN 50
int N;
L sl; // start line
int minx[MAXN];
int miny[MAXN];
int maxx[MAXN];
int maxy[MAXN];
int h[MAXN];

int ccw(P a, P b, P c) {
  b -= a; c -= a;
  if (LT( 0, cross(b, c)) )   return +1;       // counter clockwise
  if (LT( cross(b, c), 0) )   return -1;       // clockwise
  if (LT( dot(b, c), 0) )     return +2;       // c--a--b on line
  if (LT( norm(b), norm(c)) ) return -2;       // a--b--c on line
  return 0;
}


bool intersectSS(const L &s, const L &t) {
  return ccw(s[0],s[1],t[0])*ccw(s[0],s[1],t[1]) <= 0 &&
    ccw(t[0],t[1],s[0])*ccw(t[0],t[1],s[1]) <= 0;
}
bool intersectSP(const L &s, const P &p) {
  return abs(s[0]-p)+abs(s[1]-p)-abs(s[1]-s[0]) < EPS; // triangle inequality
}


P projection(const L &l, const P &p) {
  double t = dot(p-l[0], l[0]-l[1]) / norm(l[0]-l[1]);
  return l[0] + t*(l[0]-l[1]);
}


double distanceSP(const L &s, const P &p) {
  const P r = projection(s, p);
  if (intersectSP(s, r)) return abs(r - p);
  return min(abs(s[0] - p), abs(s[1] - p));
}

// USE IN THIS PROBLEM
double distanceSS(const L &s, const L &t) {
  if (intersectSS(s, t)) return 0;
  return min(min(distanceSP(s, t[0]), distanceSP(s, t[1])),
             min(distanceSP(t, s[0]), distanceSP(t, s[1])));
}

bool covered(int sx,int sy,int ex,int ey,int ax,int ay,int bx,int by) {
  return ax < sx && ay < sy && ex < bx && ey < by;
}


double solve() {
  double r = INT_MAX;
  REP(i,N) {
    L l[]={L(P(minx[i],miny[i]),P(maxx[i],miny[i])),
	   L(P(maxx[i],miny[i]),P(maxx[i],maxy[i])),
	   L(P(maxx[i],maxy[i]),P(minx[i],maxy[i])),
	   L(P(minx[i],maxy[i]),P(minx[i],miny[i]))};
    double mind = INT_MAX;
    int mini; //min index
    if(covered(real(sl[0]),imag(sl[0]),real(sl[1]),imag(sl[1]),
	       minx[i],miny[i],maxx[i],maxy[i])) return 0.0;
    REP(j,4) {
      double dd = distanceSS(l[j],sl);
      if(LT(dd,mind)) {
	mind = dd;
	mini = j;
      }
    }
    double r2;
    //printf("mind=%lf\n",mind);
    if(LE(mind,h[i])) { // mind <= h[i]
      r2=mind;
    } else {
      r2=(h[i]*h[i] + mind*mind) / (2*h[i]);
    }
    r=min(r,r2);
    //printf("r=%lf\n",r);
  }
  return r;
}
	
main() {
  while(cin>>N,N) {
    int sx,sy,ex,ey;
    cin>>sx>>sy>>ex>>ey;
    sl = L(P(sx,sy),P(ex,ey));
    REP(i,N)
      cin>>minx[i]>>miny[i]>>maxx[i]>>maxy[i]>>h[i];
    cout << solve() << endl;
  }
}

Compiler output:
a.cc:47:1: error: 'define' does not name a type
   47 | define ZEROP(x) (fabs(x) < EPS)
      | ^~~~~~
a.cc:57:27: error: 'P' does not name a type; did you mean 'PI'?
   57 |    bool operator < (const P& a, const P& b) {
      |                           ^
      |                           PI
a.cc:57:39: error: 'P' does not name a type; did you mean 'PI'?
   57 |    bool operator < (const P& a, const P& b) {
      |                                       ^
      |                                       PI
a.cc:57:9: error: 'bool std::operator<(const int&, const int&)' must have an argument of class or enumerated type
   57 |    bool operator < (const P& a, const P& b) {
      |         ^~~~~~~~
a.cc:61:20: error: 'P' does not name a type; did you mean 'PI'?
   61 | double cross(const P& a, const P& b) {
      |                    ^
      |                    PI
a.cc:61:32: error: 'P' does not name a type; did you mean 'PI'?
   61 | double cross(const P& a, const P& b) {
      |                                ^
      |                                PI
a.cc: In function 'double cross(const int&, const int&)':
a.cc:62:23: error: no match for 'operator*' (operand types are 'std::complex<double>' and 'const int')
   62 |    return imag(conj(a)*b);
      |                ~~~~~~~^~
      |                    |   |
      |                    |   const int
      |                    std::complex<double>
In file included from a.cc:11:
/usr/include/c++/14/complex:400:5: note: candidate: 'template<class _Tp> std::complex<_Tp> std::operator*(const complex<_Tp>&, const complex<_Tp>&)'
  400 |     operator*(const complex<_Tp>& __x, const complex<_Tp>& __y)
      |     ^~~~~~~~
/usr/include/c++/14/complex:400:5: note:   template argument deduction/substitution failed:
a.cc:62:24: note:   mismatched types 'const std::complex<_Tp>' and 'const int'
   62 |    return imag(conj(a)*b);
      |                        ^
/usr/include/c++/14/complex:409:5: note: candidate: 'template<class _Tp> std::complex<_Tp> std::operator*(const complex<_Tp>&, const _Tp&)'
  409 |     operator*(const complex<_Tp>& __x, const _Tp& __y)
      |     ^~~~~~~~
/usr/include/c++/14/complex:409:5: note:   template argument deduction/substitution failed:
a.cc:62:24: note:   deduced conflicting types for parameter 'const _Tp' ('double' and 'int')
   62 |    return imag(conj(a)*b);
      |                        ^
/usr/include/c++/14/complex:418:5: note: candidate: 'template<class _Tp> std::complex<_Tp> std::operator*(const _Tp&, const complex<_Tp>&)'
  418 |     operator*(const _Tp& __x, const complex<_Tp>& __y)
      |     ^~~~~~~~
/usr/include/c++/14/complex:418:5: note:   template argument deduction/substitution failed:
a.cc:62:24: note:   mismatched types 'const std::complex<_Tp>' and 'const int'
   62 |    return imag(conj(a)*b);
      |                        ^
a.cc: At global scope:
a.cc:64:18: error: 'P' does not name a type; did you mean 'PI'?
   64 | double dot(const P& a, const P& b) {
      |                  ^
      |                  PI
a.cc:64:30: error: 'P' does not name a type; did you mean 'PI'?
   64 | double dot(const P& a, const P& b) {
      |                              ^
      |                              PI
a.cc: In function 'double dot(const int&, const int&)':
a.cc:65:23: error: no match for 'operator*' (operand types are 'std::complex<double>' and 'const int')
   65 |    return real(conj(a)*b);
      |                ~~~~~~~^~
      |                    |   |
      |                    |   const int
      |                    std::complex<double>
/usr/include/c++/14/complex:400:5: note: candidate: 'template<class _Tp> std::complex<_Tp> std::operator*(const complex<_Tp>&, const complex<_Tp>&)'
  400 |     operator*(const complex<_Tp>& __x, const complex<_Tp>& __y)
      |     ^~~~~~~~
/usr/include/c++/14/complex:400:5: note:   template argument deduction/substitution failed:
a.cc:65:24: note:   mismatched types 'const std::complex<_Tp>' and 'const int'
   65 |    return real(conj(a)*b);
      |                        ^
/usr/include/c++/14/complex:409:5: note: candidate: 'template<class _Tp> std::complex<_Tp> std::operator*(const complex<_Tp>&, const _Tp&)'
  409 |     operator*(const complex<_Tp>& __x, const _Tp& __y)
      |     ^~~~~~~~
/usr/include/c++/14/complex:409:5: note:   template argument deduction/substitution failed:
a.cc:65:24: note:   deduced conflicting types for parameter 'const _Tp' ('double' and 'int')
   65 |    return real(conj(a)*b);
      |                        ^
/usr/include/c++/14/complex:418:5: note: candidate: 'template<class _Tp> std::complex<_Tp> std::operator*(const _Tp&, const complex<_Tp>&)'
  418 |     operator*(const _Tp& __x, const complex<_Tp>& __y)
      |     ^~~~~~~~
/usr/include/c++/14/complex:418:5: note:   template argument deduction/substitution failed:
a.cc:65:24: note:   mismatched types 'const std::complex<_Tp>' and 'const int'
   65 |    return real(conj(a)*b);
      |                        ^
a.cc: At global scope:
a.cc:67:26: error: 'P' was not declared in this scope
   67 | struct L : public vector<P> {
      |                          ^
a.cc:67:27: error: template argument 1 is invalid
   67 | struct L : public vector<P> {
      |                           ^
a.cc:67:27: error: template argument 2 is invalid
a.cc:69:11: error: 'P' does not name a type
   69 |   L(const P &a, const P &b) {
      |           ^
a.cc:69:23: error: 'P' does not name a type
   69 |   L(const P &a, const P &b) {
      |                       ^
a.cc: In constructor 'L::L(const int&, const int&)':
a.cc:70:5: error: 'push_back' was not declared in this scope
   70 |     push_back(a); push_back(b);
      |     ^~~~~~~~~
a.cc: At global scope:
a.cc:73:16: error: 'P' was not declared in this scope
   73 | typedef vector<P> G;
      |                ^
a.cc:73:17: error: template argument 1 is invalid
   73 | typedef vector<P> G;
      |                 ^
a.cc:73:17: error: template argument 2 is invalid
a.cc:75:4: error: 'P' does not name a type
   75 |    P p; double r;
      |    ^
a.cc:76:12: error: 'P' does not name a type
   76 |    C(const P &p, double r) : p(p), r(r) { }
      |            ^
a.cc: In constructor 'C::C(const int&, double)':
a.cc:76:30: error: class 'C' does not have any field named 'p'
   76 |    C(const P &p, double r) : p(p), r(r) { }
      |                              ^
a.cc: At global scope:
a.cc:89:9: error: 'P' was not declared in this scope
   89 | int ccw(P a, P b, P c) {
      |         ^
a.cc:89:14: error: 'P' was not declared in this scope
   89 | int ccw(P a, P b, P c) {
      |              ^
a.cc:89:19: error: 'P' was not declared in this scope
   89 | int ccw(P a, P b, P c) {
      |                   ^
a.cc:89:22: error: expression list treated as compound expression in initializer [-fpermissive]
   89 | int ccw(P a, P b, P c) {
      |                      ^
a.cc: In function 'bool intersectSS(const L&, const L&)':
a.cc:100:15: error: no match for 'operator[]' (operand types are 'const L' and 'int')
  100 |   return ccw(s[0],s[1],t[0])*ccw(s[0],s[1],t[1]) <= 0 &&
      |               ^
a.cc:100:20: error: no match for 'operator[]' (operand types are 'const L' and 'int')
  100 |   return ccw(s[0],s[1],t[0])*ccw(s[0],s[1],t[1]) <= 0 &&
      |                    ^
a.cc:100:25: error: no match for 'operator[]' (operand types are 'const L' and 'int')
  100 |   return ccw(s[0],s[1],t[0])*ccw(s[0],s[1],t[1]) <= 0 &&
      |                         ^
a.cc:100:28: error: 'ccw' cannot be used as a function
  100 |   return ccw(s[0],s[1],t[0])*ccw(s[0],s[1],t[1]) <= 0 &&
      |                            ^
a.cc:100:35: error: no match for 'operator[]' (operand types are 'const L' and 'int')
  100 |   return ccw(s[0],s[1],t[0])*ccw(s[0],s[1],t[1]) <= 0 &&
      |                                   ^
a.cc:100:40: error: no match for 'operator[]' (operand types are 'const L' and 'int')
  100 |   return ccw(s[0],s[1],t[0])*ccw(s[0],s[1],t[1]) <= 0 &&
      |                                        ^
a.cc:100:45: error: no match for 'operator[]' (operand types are 'const L' and 'int')
  100 |   return ccw(s[0],s[1],t[0])*ccw(s[0],s[1],t[1]) <= 0 &&
      |                                             ^
a.cc:100:48: error: 'ccw' cannot be used as a function
  100 |   return ccw(s[0],s[1],t[0])*ccw(s[0],s[1],t[1]) <= 0 &&
      |                                                ^
a.cc:101:10: error: no match for 'operator[]' (operand types are 'const L' and 'int')
  101 |     ccw(t[0],t[1],s[0])*ccw(t[0],t[1],s[1]) <= 0;
      |          ^
a.cc:101:15: error: no match for 'operator[]' (operand types are 'const L' and 'int')
  101 |     ccw(t[0],t[1],s[0])*ccw(t[0],t[1],s[1]) <= 0;
      |               ^
a.cc:101:20: error: no match for 'operator[]' (operand types are 'const L' and 'int')
  101 |     ccw(t[0],t[1],s[0])*ccw(t[0],t[1],s[1]) <= 0;
      |                    ^
a.cc:101:23: error: 'ccw' cannot be used as a function
  101 |     ccw(t[0],t[1],s[0])*ccw(t[0],t[1],s[1]) <= 0;
      |                       ^
a.cc:101:30: error: no match for 'operator[]' (operand types are 'const L' and 'int')
  101 |     ccw(t[0],t[1],s[0])*ccw(t[0],t[1],s[1]) <= 0;
      |                              ^
a.cc:101:35: error: no match for 'operator[]' (operand types are 'const L' and 'int')
  101 |     ccw(t[0],t[1],s[0])*ccw(t[0],t[1],s[1]) <= 0;
      |                                   ^
a.cc:101:40: error: no match for 'operator[]' (operand types are 'const L' and 'int')
  101 |     ccw(t[0],t[1],s[0])*ccw(t[0],t[1],s[1]) <= 0;
      |                                        ^
a.cc:101:43: error: 'ccw' cannot be used as a function
  101 |     ccw(t[0],t[1],s[0])*ccw(t[0],t[1],s[1]) <= 0;
      |                                           ^
a.cc: At global scope:
a.cc:103:36: error: 'P' does not name a type
  103 | bool intersectSP(const L &s, const P &p) {
      |                                    ^
a.cc: In function 'bool intersectSP(const L&, const int&)':
a.cc:104:15: error: no match for 'operator[]' (operand types are 'const L' and 'int')
  104 |   return abs(s[0]-p)+abs(s[1]-p)-abs(s[1]-s[0]) < EPS; // triangle inequality