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

struct vec2{
  long double x,y;

  vec2 operator +(vec2 const &a) const{
    return {x+a.x,y+a.y};
  }

  vec2 operator -(vec2 const &a) const{
    return {x-a.x,y-a.y};
  }

  vec2 operator *(long double const a) const{
    return {x*a,y*a};
  }

  bool operator ==(vec2 const &a) const{
    return x==a.x and y==a.y;
  }

  long double length() const{
    return hypotl(x,y);
  }

  void normalize(){
    long double l=length();
    x/=l;
    y/=l;
  }
};

long double cross(vec2 const &a,vec2 const &b){
  return a.y*b.x-a.x*b.y;
}

long double dot(vec2 const &a,vec2 const &b){
  return a.x*b.x+a.y*b.y;
}

bool between(pair<vec2,vec2> const &a,pair<vec2,vec2> const &b){
  long double c1=cross(a.second-a.first,b.first-a.first);
  long double c2=cross(a.second-a.first,b.second-a.first);
  return (c1<=0 and c2>=0) or (c2<=0 and c1>=0);
}

bool intersects(pair<vec2,vec2> const &a,pair<vec2,vec2> const &b){
  return between(a,b) and between(b,a);
}

vec2 intersection(pair<vec2,vec2> const &a,pair<vec2,vec2> const &b){
  if (a.first==b.first or a.first==b.second) return a.first;
  if (a.second==b.first or a.second==b.second) return a.second;

  vec2 ad=(a.second-a.first);
  vec2 bd=(b.second-b.first);

  vec2 d=b.first-a.first;
  long double det=cross(ad,bd);
  if (det){
    long double u=cross(d,bd)/det;
    long double v=cross(d,ad)/det;
    return a.first+(ad)*u;
  }
  else assert(false);
}

vec2 reflect(vec2 p,pair<vec2,vec2> const &l){
  vec2 n=(l.second-l.first); n.normalize();
  p=l.first-p;
  return l.first+p-n*(2*dot(p,n));
}

void dump(vector<vec2> const &v,vector<long double> const &dist){
  cerr<<"---"<<endl;
  for (int i=1; i+1<v.size(); i++){
    cerr<<" ("<<v[i].x<<" "<<v[i].y<<")="<<dist[i]<<(i%2==0?"    ":"\n");
  }
  cerr<<"\n---"<<endl;
}

int main(){
  int n; cin>>n;
  vector<vec2> v(n*2+4);
  cin>>v[0].x>>v[0].y; v[1]=v[0];
  for (auto it=v.begin()+2; it!=v.begin()+n*2+2; ++it) cin>>it->x>>it->y;
  cin>>v[n*2+2].x>>v[n*2+2].y; v[n*2+3]=v[n*2+2];

  vector<long double> dist(n*2+4,1e80L);
  vector<vec2> w=v;
  dist[1]=0;

  for (int i=2; i<n*2+3; i++){
    for (int j=1; j/2<i/2; j++){
      for (int flips=(1<<(i/2-j/2)); flips--;){

        w=v;
        for (int k=j/2+1; k<i/2; k++)
          if (flips&(1<<(k-(j/2+1))))
            for (int l=j; l<k*2; l++)
              w[l]=reflect(w[l],{w[k*2],w[k*2+1]});

        vec2 a=w[j];
        vec2 b=w[i];

        long double score=dist[j]+(b-a).length();
        if (score>=dist[i]){
          continue;
        }
        bool ok=true;
        for (int k=(j&~0x1)+2; k/2<i/2; k+=2){
          if (not intersects({a,b},{w[k],w[k+1]})){
            ok=false;
            break;
          }
          a=intersection({a,b},{w[k],w[k+1]});
        }
        if (ok){
          dist[i]=score;
        }
      }
    }
  }

  cout.precision(8);
  cout<<fixed<<dist[n*2+2]<<endl;
}