//GNC

#include<iostream>
#include<string>
#include <vector>
#include <algorithm>
#include <map>
#include <set>
#include <fstream>
#include <sstream>
#include <iterator>
#include <cassert>
#include <complex>
#include <iomanip>
#include <queue>
#include <cmath>
#include <functional>
using namespace std;
typedef vector<int> array;
typedef double base;
typedef complex<base> xy;
typedef vector<xy> polygon;

const double EPS=1.0e-12;
#define LT(x,y) ((x)-(y)<-EPS)

base innerProduct(xy p, xy q) { return real(conj(p)*q);}
base outerProduct(xy p, xy q) { return imag(conj(p)*q);}
int ccw(xy p1, xy p2, xy p3)
{
  p2-=p1; p3-=p1;
  if ( LT(0,outerProduct(p2,p3)) ) return +1;
  if ( LT(outerProduct(p2,p3),0) ) return -1;
  if ( LT(p2.real()*p3.real(),0) ||
       LT(p2.imag()*p3.imag(),0) ) return +2;
  if ( LT(norm(p2),norm(p3)) ) return -2;
  return 0;
}

bool intersect(xy p1, xy p2, xy p3, xy p4)
{
  return (ccw(p1,p2,p3)*ccw(p1,p2,p4))<=0 &&
    (ccw(p3,p4,p1)*ccw(p3,p4,p2))<=0;
}
typedef int point;
typedef double weight;
struct edge{
  point dest;
  weight w;
  edge(){}
  edge(const point &dest, const weight &w):dest(dest),w(w){}
};
bool operator>(const edge&lhs, const edge&rhs)
{
  return LT(rhs.w,lhs.w);
}
typedef vector<edge> edges;
typedef map<point,edges> graph;
typedef map<point,weight> potential;

potential dijkstra(graph &g, const vector<point> &st)
{
  potential pot;
  priority_queue<edge, edges, greater<edge> > toBeProcessed;
  for ( int i=0 ; i<st.size() ; ++i )
    toBeProcessed.push(edge(st[i],0));
  while ( !toBeProcessed.empty()) {
    edge top=toBeProcessed.top();
    point p=top.dest;
    weight curr=top.w;
    toBeProcessed.pop();
    if ( pot.count(p)!=0 ) continue;
    pot[p]=curr;
    
    edges& es=g[p];
    for ( int i=0 ; i<es.size(); ++i ) {
      edge&e=es[i];
      if ( pot.count(e.dest)!=0 ) continue;
      toBeProcessed.push(edge(e.dest, curr+e.w));
    }
  }
  return pot;
}

void makeEdges(graph &g, const polygon &po, const polygon &po_purt, int from, int to)
{
  //cout<<"from"<<from<<" to"<<to<<endl;
  xy pofrom=po[from/8];
  xy poto = po[to/8];
  xy diff=pofrom-poto;
  weight dist=sqrt((double)norm(diff));
  g[from].push_back(edge(to,dist));
  g[to].push_back(edge(from,dist));
}

int sgn(base s)
{
  if ( s>0 ) return 1;
  if ( s==0 ) return 0;
  return -1;
}

graph polygon2graph(const polygon &po)
{
  graph g;
  polygon v;
  for ( int i=0 ; i<po.size() ; i++ ) {
    double e=1.0e-4;
    double sq2=sqrt(2.0);
    v.push_back(po[i]-xy(sq2*e,e));
    v.push_back(po[i]+xy(sq2*e,e));
    v.push_back(po[i]-xy(sq2*e,-e));
    v.push_back(po[i]+xy(sq2*e,-e));
    v.push_back(po[i]-xy(e,sq2*e));
    v.push_back(po[i]+xy(e,sq2*e));
    v.push_back(po[i]-xy(-e,sq2*e));
    v.push_back(po[i]+xy(-e,sq2*e));
  }
  /*for ( int i=0 ; i<po.size()-1 ; i++ ) {
    makeEdges(g, po, i, i+1);
    }*/
  for ( int from=0 ; from<v.size()-1 ; from++ ) {
    const xy &fx=v[from];
    for ( int to=from+1 ; to<v.size() ; to++ ) {
      const xy &tx=v[to];
      /*if ( from>0 &&
	   sgn(outerProduct(tx-fx, po[from-1]-fx))*sgn(outerProduct(po[from+1]-fx,po[from-1]-fx))>0 &&
	   sgn(outerProduct(tx-fx, po[from+1]-fx))*sgn(outerProduct(po[from-1]-fx,po[from+1]-fx))>0 ) {
	continue;
      }
      if ( to<po.size()-1 &&
	   sgn(outerProduct(fx-tx, po[to-1]-tx))*sgn(outerProduct(po[to+1]-tx,po[to-1]-tx))>0 &&
	   sgn(outerProduct(fx-tx, po[to+1]-tx))*sgn(outerProduct(po[to-1]-tx,po[to+1]-tx))>0 ) {
	continue;
	}*/
      bool ok=true;
      for ( int i=0 ; i<po.size()-1 ; i++ ) {
	const xy &p=po[i];
	const xy &q=po[i+1];
	if ( intersect(fx, tx, p, q) ) {
	  ok=false;
	  break;
	}
      }
      if ( !ok ) continue;
      makeEdges(g, po, v, from, to);
    }
  }
  return g;
}

int main(void)
{
  int nlines;
  ifstream cin("hedge.in");

  while ( cin>>nlines && nlines>0 ) {
    polygon po;
    for ( int i=0 ; i<nlines ; i++ ) {
      int x, y;
      cin>>x>>y;
      po.push_back(xy(x,y));
    }
    graph g=polygon2graph(po);
    /*
    for ( graph::iterator it=g.begin() ;it!=g.end() ; ++it ) {
      cout<<"from "<<(it->first)/8 << ":" << (it->first)%8 << " ";
      edges &es=it->second;
      for ( int i=0 ; i<es.size() ; ++i ) {
	cout<<(es[i].dest)/8 << ":" << (es[i].dest)%8<<"("<<es[i].w<<"), ";
      }
      cout<<endl;
    } 
    */
    vector<point> st;
    for ( int i=0 ; i<8 ; i++ )
      st.push_back(i);
    potential pot=dijkstra(g, st);
    cout.setf(ios::fixed);
    cout<<setprecision(7);
    weight m=1.0e+10;
    for ( int i=0 ; i<8 ; i++ ) {
      if ( pot.count(nlines*8-1-i)>0 )
	m=min(m, pot[nlines*8-1-i]);
    }
    cout<<m<<endl;
  }
  return 0;
}