#include <math.h>
#include <stdio.h>
#include <algorithm>

#define eps 1e-8

using namespace std;

struct pq
{
  void init(double a,double b) { x = a; y = b; }
  double x,y;
};
struct pt
{
  void init(double a,double b, int c, int d) { x = a; y = b; i = c; j = d; }
  double x,y;
  int i, j;
};
struct is
{
  int i, n;
  double x,y;
};

int n, N, r;
int x[100], y[100];
is s[100][100];
int sz[100];
pt g[10000];
int cv[10000];
int m[10000][100], nv[10000];
pq list[10000];
int ls;
pq p[10000];

int operator<(const is &a, const is &b)
{
  if(a.x < b.x-eps) return 1; if(a.x > b.x+eps) return 0;
  return a.y < b.y;
}
int operator<(const pt &a, const pt &b)
{
  if(a.x < b.x-eps) return 1; if(a.x > b.x+eps) return 0;
  return a.y < b.y;
}

double vec(double a,double b,double c,double d)
{
  return a*d-b*c;
}

int bound(int a, int b, int c, int d)
{
  if(a > b) swap(a, b);
  if(c > d) swap(c, d);
  if(a > c)
  {
    swap(a, c);
    swap(b, d);
  }
  return b >= c;
}

int isect(int a, int b, int c, int d, int e, int f, int g, int h, double &p, double &q)
{
double a11,a12,a13,a21,a22,a23,D;
  if(!bound(a,c,e,g) || !bound(b,d,f,h)) return 0;
  if(vec(c-a,d-b,e-a,f-b)*vec(c-a,d-b,g-a,h-b) < 0 ||
     vec(g-e,h-f,a-e,b-f)*vec(g-e,h-f,c-e,d-f) < 0) return 0;
  a11 = b-d; a12 = c-a; a13 = c*b-d*a;
  a21 = h-f; a22 = g-e; a23 = g*f-e*h;
  D = a11*a22-a12*a21;
  p = (a13*a22-a12*a23) / D;
  q = (a11*a23-a21*a13) / D;
  return 1;
}

int pteq(double a,double b,double c,double d)
{
  return fabs(a-c) < eps && fabs(d-b) < eps;
}

void traverse(int f)
{
int i, v, j, k, f0;
double x0,y0, t, b;
  f0 = f;
  x0 = x[f]-1; y0 = y[f];
  do
  {
    list[ls].x = p[f].x;
    list[ls].y = p[f].y;
    ++ls;
    b = 1e50;
    for(i = 0; i < nv[f]; i++)
    {
      j = m[f][i];
      t = vec(x[f]-x0,y[f]-y0,x[j]-x[f],y[j]-y[f]);
      if(t < b) { b = t; k = j; }
    }
    f = j;
  } while(f != f0);
}

int main(void)
{
int i,j,k,l,f;
double pp,qq;
  freopen("find.in",  "rt", stdin);
  freopen("find.out", "wt", stdout);
  scanf("%d", &n);
  for(i = 0; i < n; i++) scanf("%d%d", &x[i], &y[i]);
  for(i = 0; i < n; i++)
  {
    j = (i+1); if(j == n) j = 0;
    for(k = 0; k < n; k++)
    {
      if(i == k) continue;
      l = (k+1); if(l == n) l = 0;

      if(!isect(x[i],y[i],x[j],y[j],x[k],y[k],x[l],y[l], pp,qq)) continue;
      s[i][sz[i]].i = k;
      s[i][sz[i]].x = pp;
      s[i][sz[i]].y = qq;
      ++sz[i];
    }
    stable_sort(s[i], s[i]+sz[i]);
    for(j = 0; j < sz[i]; j++)
    {
      s[i][j].n = r;
      g[r].init(s[i][j].x,s[i][j].y,i,j);
      ++r;
    }
  }
  stable_sort(g, g+r);
  for(i = 0; i < r; i++)
  {
    if(!i || !pteq(g[i].x,g[i].y,g[i-1].x,g[i-1].y))
    {
      ++N;
      s[g[i].i][g[i].j].n = N-1;
      p[N-1].x = g[i].x;
      p[N-1].y = g[i].y;
    }
    else
    {
      s[g[i].i][g[i].j].n = s[g[i-1].i][g[i-1].j].n;
    }
  }
  for(i = 0; i < r; i++)
  {
    int u = s[g[i].i][g[i].j].n;
    if(g[i].j < sz[g[i].i]-1)
      m[u][nv[u]++] = s[g[i].i][g[i].j+1].n;
    if(g[i].j)
      m[u][nv[u]++] = s[g[i].i][g[i].j-1].n;
  }

  for(f=0,i=1; i < n; i++)
    if(p[i].y < p[f].y || (p[i].y == p[f].y && p[i].x < p[f].x)) f = i;
  traverse(f);
  for(j=1,i=2; i < ls; i++)
  {
    if(fabs(vec(list[j].x-list[j-1].x,list[j].y-list[j-1].y,list[i].x-list[j].x,list[i].y-list[j].y)) < eps) continue;
    list[++j] = list[i];
  }
  ls = j+1;
  printf("%d\n", ls);
  for(i = 0; i < ls; i++) printf("%.10lf %.10lf\n", list[i].x, list[i].y);
  return 0;
}