// team13

#include <iostream>
#include <fstream>
#include <complex>
#include <vector>
#include <map>
#include <cmath>
#include <iomanip>
#include <cassert>
using namespace std;

typedef complex<double> pt;
const double epsilon = 1e-10;
const double heps = 1e-5;
const double eps=epsilon;
double pi = atan(1.0 )*4;

namespace std{
  bool operator<(const pt&a, const pt&b){
    if(abs(imag(a)-imag(b))>epsilon) return imag(a)<imag(b);
    return real(a)<real(b);
  }
}

double area(pt a, pt b, pt c){ return imag(conj(b-a)*(c-a));} 

vector<pt> hull(vector<pt> &v){
  pt o = *min_element(v.begin(), v.end());
  multimap<pair<double,double> ,pt > m;
  for(int i=0;i<v.size();i++)
    if(abs(v[i]-o) >= epsilon)
      m.insert(make_pair(make_pair(arg(v[i]-o), abs(v[i]-o)), v[i]));
  m.insert(make_pair(make_pair(10,0),o));
  vector<pt> ret(1,o);
  for(multimap<pair<double,double>,pt >::iterator p = m.begin();
      p!=m.end();p++){
    ret.push_back(p->second);
    for(int n=ret.size(); n>=3 && area(ret[n-3],ret[n-2],ret[n-1])<epsilon;n--)
      ret[n-2]=ret[n-1],ret.pop_back();
  }
  return ret;
}

bool cut(pt a, pt u, pt b, pt v){
  double det = imag(conj(u)*v);
  if(abs(det)<eps){
    b /= u;
    v /= u;
    a /= u;
    u /= u;
    b-=a; a-=a;
    pt c=b+v;
    if(abs(imag(b))>eps || abs(imag(c))>eps) return false;
    if(real(b) > 1+eps && real(c) > 1+eps) return false;
    if(real(b) < -eps && real(c) < -eps) return false;
    return true;
  }
  double s = -imag(conj(v) * (b-a))/det;
  double t = -imag(conj(u) * (b-a))/det;
  if( (-eps<t) && (t<1+eps) && (-eps<s) && (s<1+eps) ) return true;
  return false;
}

const bool debug = false;

int main()
{
  cout<<setiosflags(ios::fixed)<<setprecision(10);
  ifstream cin("hedge.in");
  for(int n;cin>>n,n;){
    vector<pt> hedge(n);
    for(int i=0;i<n;i++){
      double x,y;cin>>x>>y;
      hedge[i]=pt(x,y);
    }
    
    vector<pt> verts;
    vector<pt> original;
    int st, ed;
    double ar;
    ar=arg(hedge[1]-hedge[0]);
    verts.push_back(hedge[0] + polar(heps,ar+pi));
    original.push_back(hedge[0]);
    verts.push_back(hedge[0] + polar(heps,ar+0.5*pi));
    original.push_back(hedge[0]);
    verts.push_back(hedge[0] + polar(heps,ar+1.5*pi));
    original.push_back(hedge[0]);
    st = 0;
    
    ar=arg(hedge[n-2]-hedge[n-1]);
    verts.push_back(hedge[n-1] + polar(heps,ar+pi));
    original.push_back(hedge[n-1]);
    verts.push_back(hedge[n-1] + polar(heps,ar+0.5*pi));
    original.push_back(hedge[n-1]);
    verts.push_back(hedge[n-1] + polar(heps,ar+1.5*pi));
    original.push_back(hedge[n-1]);
    ed = 3;
    
    for(int i=1;i<n-1;i++){
      int ip=i-1, in=i+1;
      double ar = (arg(hedge[ip]-hedge[i]) + arg(hedge[in]-hedge[i]) )/2;
      verts.push_back(hedge[i]+polar(heps,ar));
      original.push_back(hedge[i]);
      verts.push_back(hedge[i]-polar(heps,ar));
      original.push_back(hedge[i]);
      verts.push_back(hedge[i]+polar(heps,ar+0.5*pi));
      original.push_back(hedge[i]);
      verts.push_back(hedge[i]+polar(heps,ar+1.5*pi));
      original.push_back(hedge[i]);
    }
    vector<vector<pair<double,int> > > g(verts.size());
    
    for(int i=0;i<verts.size();i++){
      for(int j=i+1;j<verts.size();j++){
        bool ok=true;
        for(int k=0;k<hedge.size()-1;k++){
          if(cut(hedge[k],hedge[k+1]-hedge[k] , verts[i],verts[j]-verts[i])){
            if(debug) cout << i << "-" << j << " is broken by " << k << "-" << (k+1) << endl;
            ok=false;
            break;
          }
        }
      
        if(ok){
          double d = abs(original[i] - original[j]);
          g[i].push_back(make_pair(d,j));
          g[j].push_back(make_pair(d,i));
        }
      }
    }

    if(debug){
      cout << "created graph" << endl;
      for(int i=0;i<g.size();i++){
        cout << verts[i] << "=";
        cout << i << " connects to ";
        for(int j=0;j<g[i].size();j++){
          cout << g[i][j].second << " ";
        }
      if(i==st) cout << "st";
        if(i==ed) cout << "ed";
        cout << endl;
      }
    }
    multimap<double,int> mm;
    vector<double> cost(g.size(),-1);
    mm.insert(make_pair(0,st));
    while(!mm.empty()){
      double c=mm.begin()->first;
      int ix=mm.begin()->second;
      mm.erase(mm.begin());
      if (cost[ix]>=-eps) continue;
      cost[ix]=c;
      if (ix==ed) break;
      for (int i=0;i<g[ix].size();i++){
        double nc=c+g[ix][i].first;
        int nx=g[ix][i].second;
        if (cost[nx]>=-eps) continue;
        mm.insert(make_pair(nc,nx));
      }
    }
    
    cout<<cost[ed]<<endl;
    /*
    bool sp=true;
    for (int i=0;i<n-2;i++){
      if (!(abs(arg((hedge[i+2]-hedge[i+1])/(hedge[i+1]-hedge[i])))<eps)){
        sp=false;
        break;
      }
    }
    if (sp){
      cout<<abs(hedge[n-1]-hedge[0])<<endl;
      continue;
    }
    
    pt st=hedge[0],ed=hedge[n-1];
    vector<pt> h=hull(hedge);
    //cout<<h[0]<<" "<<h[1]<<endl;
    h.push_back(h[0]);
    double total=0;
    for (int i=1;i<h.size();i++)
      total+=abs(h[i-1]-h[i]);
    double sub=0;
    bool flg=false;
    for (int i=1;i<h.size();i++){
      if (abs(h[i-1]-st)<eps||abs(h[i-1]-ed)<eps){
        flg=!flg;
        if (!flg) break;
      }
      if (flg)
        sub+=abs(h[i-1]-h[i]);
    }
    //cout<<"total: "<<total<<endl;
    //cout<<"sub: "<<sub<<endl;
    cout<<(sub<?total-sub)<<endl;
      */
  }
  return 0;
}