//0 <= n <= 30    
  
#include<iostream>  
#include <algorithm>  
#include<cmath>  
using namespace std;  
  
//Dijkstra算法模板开始  
//==============================================  
#define MAX 105  
#define INF 0x11111111  
#define TRUE 1  
#define FALSE 0  
  
typedef struct{  
    //double info;  
}VertexType;  
  
typedef struct{  
    double val;  
    //double info;  
}ArcType,ArcMatrix[MAX][MAX];  
  
typedef struct{  
    int vexnum;  
    VertexType vexs[MAX];  
    ArcMatrix arcs;  
}MGraph;  
  
typedef double ShortPathTable[MAX];  
  
void ShortestPath_DIJ(MGraph &G,int v0, ShortPathTable &D)  
{  
    // 用Dijkstra算法求有向网G的v0顶点到其余顶点v的最短路径P[v]  
    // 及其带权长度D[v]。  
    // 若P[v][w]为TRUE，则w是从v0到v当前求得最短路径上的顶点。  
    // final[v]为TRUE当且仅当v∈S,即已经求得从v0到v的最短路径。  
    int i=0, v,w;  
    double min;  
    bool final[MAX];  
    for (v=0; v<G.vexnum; ++v)  
    {  
        final[v] = FALSE;    
        D[v] = G.arcs[v0][v].val;  
    }  
    D[v0] = 0; final[v0] = TRUE;        // 初始化，v0顶点属于S集  
    //--- 开始主循环，每次求得v0到某个v顶点的最短路径，并加v到S集 ---  
    for (i=1; i<G.vexnum; ++i)           // 其余G.vexnum-1个顶点  
    {  
        min = INF;                  // 当前所知离v0顶点的最近距离  
        for (w=0; w<G.vexnum; ++w)  
            if (!final[w])                             // w顶点在V-S中  
                if (D[w]<min) { v = w; min = D[w]; } // w顶点离v0顶点更近  
        final[v] = TRUE;                       // 离v0顶点最近的v加入S集  
        for (w=0; w<G.vexnum; ++w)             // 更新当前最短路径及距离  
            if (!final[w] && (min+G.arcs[v][w].val<D[w])) {    
                // 修改D[w]和P[w], w∈V-S  
                D[w] = min + G.arcs[v][w].val;  
            }//if  
    }//for  
} // ShortestPath_DIJ  
MGraph g;  
ShortPathTable d;  
//=========================================================  
  
//判断线段相交、距离、差积的计算  
//========================================================  
struct point  
{   double x,y;  };    
struct line  
{   point s, e;  };  
double max(double a,double b)  
{   return a>b?a:b;      }  
double min(double a,double b)  
{   return a<b?a:b;      }  
  
//计算距离  
double dist(point p1,point p2)  
{   double x1=p1.x-p2.x,y1=p1.y-p2.y;  
    return sqrt(x1*x1+y1*y1);    
}  
//计算叉积  
double multi(point p0,point p1,point p2)  
{   return (p1.x-p0.x)*(p2.y-p0.y)-(p2.x-p0.x)*(p1.y-p0.y);}  
//判断线段相交  差积有等于号时为非规范相交，无等号为规范相交  
bool is_cross(point s1,point e1,point s2,point e2)  
{  
   return max(s1.x,e1.x)>=min(s2.x,e2.x)&&  
          max(s2.x,e2.x)>=min(s1.x,e1.x)&&  
          max(s1.y,e1.y)>=min(s2.y,e2.y)&&  
          max(s2.y,e2.y)>=min(s1.y,e1.y)&&  
          multi(s2,e1,s1)*multi(e1,e2,s1)>0&&  
          multi(s1,e2,s2)*multi(e2,e1,s2)>0;  
}  
//============================================================  
  
//0 < x < 10  
int main()  
{  
    int n;  
    int i,j,k,s,t;  
    double x,y1,y2,y3,y4,temp;  
    line segment[60];  
    point p[MAX];  
    while(cin>>n)  
    {  
        if(n==-1)break;  
        p[0].x=0;p[0].y=5;j=1;k=0;  
        for(i=0;i<n;i++)  
        {  
            cin>>x>>y1>>y2>>y3>>y4;  
            p[j].x=x;p[j].y=y1;j++;  
            p[j].x=x;p[j].y=y2;j++;  
            p[j].x=x;p[j].y=y3;j++;  
            p[j].x=x;p[j].y=y4;j++;  
            segment[k].s.x=x;segment[k].s.y=0;segment[k].e.x=x;segment[k].e.y=y1;k++;  
            segment[k].s.x=x;segment[k].s.y=y2;segment[k].e.x=x;segment[k].e.y=y3;k++;  
            segment[k].s.x=x;segment[k].s.y=y4;segment[k].e.x=x;segment[k].e.y=10;k++;  
        }  
        p[j].x=10;p[j].y=5;  
        g.vexnum = j+1;  
        //memset(g.arcs,INF,sizeof(g.arcs));  
        //memset(d,INF,sizeof(d));    
        for(i=0;i<=j;i++)  
            for(s=0;s<=j;s++)  
                g.arcs[i][s].val=INF;  
        for(i=0;i<=j+1;i++)d[i]=INF;  
        for(i=0;i<j;i++)  
            for(s=i+1;s<=j;s++)  
            {  
                for(t=0;t<k;t++)  
                     if(is_cross(p[i],p[s],segment[t].s,segment[t].e)&&p[i].x!=p[s].x)break;  
                if(t==k)  
                {  
                    temp=dist(p[i],p[s]);  
                    g.arcs[i][s].val=temp;  
                    g.arcs[s][i].val=temp;  
                }  
            }  
        ShortestPath_DIJ(g,0,d);  
        printf("%.2lf\n",d[j]);  
    }    
    return 0;  
}