#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>

#define inpfile "polygon.in"
#define outfile "polygon.out"

#define INF 1e20
#define EPS 1e-10
#define NMAX 105

struct COORD {
	double x,y;
};


//Global variables
COORD a[NMAX];
COORD tower={0,0};
int n;
double res;
//----------------

void Init()
{
	freopen(inpfile,"r",stdin);
	freopen(outfile,"w",stdout);
}

void Out()
{
	printf("%.10lf",res);
	exit(0);
}

void Inp()
{
	int i;

	scanf("%d",&n);
	for (i=0; i<n; i++)
		scanf("%lf %lf",&a[i].x,&a[i].y);
	
	a[n]=a[0];
}

double sqr(double x)
{
	return x*x;
}

double Len(COORD *p1, COORD *p2)
{
	return sqrt(sqr(p2->x - p1->x) + sqr(p2->y - p1->y));
}

double Vc(COORD *p1, COORD *p2, COORD *p3, COORD *p4)
{
	return (p2->x - p1->x)*(p4->y - p3->y) - (p2->y - p1->y)*(p4->x - p3->x);
}

double Sc(COORD *p1, COORD *p2, COORD *p3, COORD *p4)
{
	return (p2->x - p1->x)*(p4->x - p3->x) + (p2->y - p1->y)*(p4->y - p3->y);
}

double Cross(COORD *p1, COORD *p2, COORD *p3, COORD *p4)
{
	double v1,v2;
	COORD r;

	v1=Vc(p3,p1,p3,p4);
	v2=Vc(p1,p2,p3,p4);

	if (fabs(v2)<EPS) return -1;
	if (Vc(p1,p2,p1,p3)*Vc(p1,p2,p1,p4)>0) return -1;

	r.x=p1->x - (p2->x - p1->x)*v1/v2;
	r.y=p1->y - (p2->y - p1->y)*v1/v2;

	if (Sc(p1,p2,p1,&r)<-EPS) return -1;
	return Len(p1,&r);
}

double DistToLine(COORD *q, COORD *p1, COORD *p2)
{
	return fabs(Vc(q,p1,q,p2)/Len(p1,p2));
}

double Sn(COORD *p1, COORD *p2, COORD *p3, COORD *p4)
{
	if (Sc(p1,p2,p3,p4)>0) return 1;
	else return -1;
}

double Count(COORD *p1, COORD *p2, COORD *p3, COORD *p4, COORD *r)
{
	if ((fabs(Vc(p1,p2,p1,&tower))<EPS) || (fabs(Vc(p3,p4,p3,&tower))<EPS)) return -1;
	
	COORD p,q,ox,oy;
	COORD q1,q2,q3;
	double v1,v2;
	double d1,d2,p1p2;
	double a,b,c,x;
	double res;
	
	if (fabs(Vc(p1,p2,p3,p4))<EPS) {
		if ((Vc(p1,p2,p1,&tower)*Vc(p1,p2,p1,p3)>EPS) &&
		    (Vc(p3,p4,p3,&tower)*Vc(p3,p4,p3,p1)>EPS)) return -1;

		p.x=tower.x+(p2->y - p1->y);
		p.y=tower.y-(p2->x - p1->x);
		if ((Vc(&tower,&p,&tower,p1)*Vc(&tower,&p,&tower,p2)>EPS) ||
		    (Vc(&tower,&p,&tower,p3)*Vc(&tower,&p,&tower,p4)>EPS)) return -1;

		d1=DistToLine(&tower,p1,p2);
		d2=DistToLine(&tower,p3,p4);

		v1=Vc(p1,&tower,p1,p2);
		v2=Vc(&tower,&p,p1,p2);
		r->x=tower.x - (p.x-tower.x)*v1/v2;
		r->y=tower.y - (p.y-tower.y)*v1/v2;
		return d1*d2;
	}

	ox.x=tower.x+(p2->x - p1->x);
	ox.y=tower.y+(p2->y - p1->y);
	oy.x=tower.x+(p2->y - p1->y);
	oy.y=tower.y-(p2->x - p1->x);

	if (Sc(&tower,&oy,&tower,p1)<-EPS) {
		oy.x=-oy.x;
		oy.y=-oy.y;
	}

	v1=Vc(p3,&tower,p3,p4);
	v2=Vc(&tower,&ox,p3,p4);
	q1.x=tower.x - (ox.x-tower.x)*v1/v2;
	q1.y=tower.y - (ox.y-tower.y)*v1/v2;

	v1=Vc(p3,p1,p3,p4);
	v2=Vc(p1,p2,p3,p4);
	q2.x=p1->x - (p2->x - p1->x)*v1/v2;
	q2.y=p1->y - (p2->y - p1->y)*v1/v2;

	v1=Vc(p1,&tower,p1,p2);
	v2=Vc(&tower,&oy,p1,p2);
	q3.x=tower.x - (oy.x-tower.x)*v1/v2;
	q3.y=tower.y - (oy.y-tower.y)*v1/v2;

	a=Len(&tower,&q1)*Sn(&tower,&ox,&tower,&q1);
	b=Len(&q2,&q3)*Sn(&tower,&ox,&q3,&q2);
	c=Len(&tower,&q3);

	x=b-a + sqrt(sqr(a-b)+sqr(c));
	res=(a*(sqr(x)+sqr(c)))/(x-b+a);

	if (res<0) {
		x=b-a - sqrt(sqr(a-b)+sqr(c));
		res=(a*(sqr(x)+sqr(c)))/(x-b+a);
	}

	p1p2=Len(p1,p2);
	p.x=q3.x+(p2->x - p1->x)*x/p1p2;
	p.y=q3.y+(p2->y - p1->y)*x/p1p2;
	
	v1=Vc(p3,&tower,p3,p4);
	v2=Vc(&tower,&p,p3,p4);
	q.x=tower.x - (p.x-tower.x)*v1/v2;
	q.y=tower.y - (p.y-tower.y)*v1/v2;

	if ((Sc(&p,p1,&p,p2)>EPS) || (Sc(&q,p3,&q,p4)>EPS)) return -1;
	
	*r=p;
	return Len(&tower,&p)*Len(&tower,&q);
}

void Solve()
{
	int i,j,k;
	double dmin,dmax,d;
	COORD p;
	
	res=INF;
	for (i=0; i<n; i++) {
		dmin=Len(&tower,&a[i]);
		dmax=dmin;

		for (j=0; j<n; j++) {
			d=Cross(&tower,&a[i],&a[j],&a[j+1]);
			if (d>0) {
				if (d<dmin) dmin=d;
				if (d>dmax) dmax=d;
			}
		}

		if (res>dmin*dmax) res=dmin*dmax;
	}

	for (i=0; i<n-1; i++)
		for (j=i+1; j<n; j++) {
			d=Count(&a[i],&a[i+1],&a[j],&a[j+1],&p);
			if (d>0) {
				dmin=Len(&tower,&p);
				dmax=dmin;

				for (k=0; k<n; k++) {
					d=Cross(&tower,&p,&a[k],&a[k+1]);
					if (d>0) {
						if (d<dmin) dmin=d;
						if (d>dmax) dmax=d;
					}
				}

				if (res>dmin*dmax) res=dmin*dmax;
			}
		}
}

int main()
{
	Init();
	Inp();
	Solve();
	Out();

	return 0;
}
