#include<iostream>
#include<vector>
#include<algorithm>
#include<cmath>
#include<cstdlib>
using namespace std;

struct point{
  double x;
  double y;
  double angle;
};

int n;
point init;
vector<point> points;
vector<point> hull;

void angle_sort();
void compute_hull();
bool tree_on_hull();
double hull_length();
double hull_to_tree();
double hull_with_gap(int index);
bool in_line();


bool small_angle(const struct point &p1,const struct point &p2)
{return(p1.angle > p2.angle);}

double ccw(struct point &p1,struct point &p2,struct point &p3)
{return((p2.x-p1.x)*(p3.y-p1.y) - (p2.y-p1.y)*(p3.x-p1.x));}

double distance(double x1,double y1,double x2,double y2)
{return(sqrt((x2-x1)*(x2-x1)+(y2-y1)*(y2-y1)));};

int main ()
{
  int i;

  while(cin>>n)
    {
      for(i=0;i<n;i++)
	{
	  point *p = new point;
	  cin>>p->x>>p->y;
	  points.push_back(*p);
	}


      angle_sort();

      compute_hull();

      if(tree_on_hull()||in_line()) printf("%.2lf\n",hull_length());
      else printf("%.2lf\n",hull_to_tree());

      points.clear();
      hull.clear();
    }

  return(0);
}

void angle_sort()
{
  init = points[0];
  int i;

  for(i=1;i<points.size();i++)
    {
      if((points[i].y < init.y) ||
	 (points[i].y == init.y && points[i].x < init.x)) init = points[i];
    }

  //angle is really holding the cotangent, which decreases as theta increases
  for(i=0;i<points.size();i++)
    {
      if(points[i].x != init.x || points[i].y != init.y)
	{
	  if(points[i].y-init.y == 0) 
	    points[i].angle = INFINITY;
	  else points[i].angle = (points[i].x-init.x)/(points[i].y-init.y);
	}
      else points[i].angle = -INFINITY;
    }

  sort(points.begin(),points.end(),small_angle);
}

void compute_hull()
{
  int i;

  hull.push_back(init);
  hull.push_back(points[0]);

  for(i=1;i<(n-1);i++)
    {
      while(ccw(hull[hull.size()-2],hull[hull.size()-1],points[i])<0) 
	hull.pop_back();
	
      hull.push_back(points[i]);
    }

}

bool tree_on_hull()
{
  int i;
  for(i=0;i<hull.size();i++) 
    if(hull[i].x==0 && hull[i].y==0) return(true);
  return(false);
}

double hull_length()
{
  int i;
  double total=0;
  for(i=0;i<(hull.size()-1);i++)
    {
      total += distance(hull[i].x,hull[i].y,hull[i+1].x,hull[i+1].y);
    }

  total+=distance(hull[hull.size()-1].x,hull[hull.size()-1].y,hull[0].x,hull[0].y);

  total+=2;

  return(total);
}

double hull_to_tree()
{
  double min,tmp;
  int index,i;

  min = distance(0,0,hull[hull.size()-1].x,hull[hull.size()-1].y) + 
    distance(0,0,hull[0].x,hull[0].y);
  index = hull.size()-1;

  for(i=0;i<(hull.size()-1);i++)
    {
      tmp = distance(0,0,hull[i].x,hull[i].y) + 
	distance(0,0,hull[i+1].x,hull[i+1].y);
      if(tmp < min)
	{
	  min = tmp;
	  index = i;
	}
    }

  min += hull_with_gap(index);

  return(min);

}

double hull_with_gap(int index)
{
  int i;
  double total=0;
  for(i=0;i<(hull.size()-1);i++)
    {
      if(i!=index)
	total += distance(hull[i].x,hull[i].y,hull[i+1].x,hull[i+1].y);
    }

  if(index != hull.size()-1)
    total+=distance(hull[hull.size()-1].x,hull[hull.size()-1].y,
		    hull[0].x,hull[0].y);

  total+=2;

  return(total);
}

bool in_line()
{
  int i;
  for(i=0;i<hull.size()-1;i++)
    {
      if((distance(hull[i].x,hull[i].y,0,0)+
	  distance(hull[i+1].x,hull[i+1].y,0,0))==
	  distance(hull[i].x,hull[i].y,hull[i+1].x,hull[i+1].y)) return(true);
    }

  if(distance(hull[hull.size()-1].x,hull[hull.size()-1].y,hull[0].x,hull[0].y)
     == (distance(hull[hull.size()-1].x,hull[hull.size()-1].y,0,0) +
	 distance(hull[0].x,hull[0].y,0,0))) return(true);


  return(false);
}