program polygon;

uses
	sysutils, math;

const
	maxn = 100;
	eps = 1e-6;
	maxt = maxn * maxn + maxn;

function between(x, y, z: extended): boolean;
begin
	between := 
		((x - eps < y) and (y < z + eps)) or
		((z - eps < y) and (y < x + eps));
end;

function isect(ang: extended; x1, y1, x2, y2: extended; var xc, yc: extended): boolean;
var
	a1, a2, b1, b2, c1, c2, d: extended;
begin
	a1 := sin(ang);
	b1 := -cos(ang);
	c1 := 0;
	a2 := y2 - y1;
	b2 := x1 - x2;
	d := hypot(a2, b2);
	a2 := a2 / d;
	b2 := b2 / d;
	c2 := x1 * a2 + y1 * b2;
	d := a1 * b2 - a2 * b1;

	isect := false;
	if (abs(d) < eps) then exit;

	xc := (c1 * b2 - c2 * b1) / d;
	yc := (a1 * c2 - a2 * c1) / d;
	if (abs(arctan2(yc, xc) - ang) > eps) then exit;

	if not between(x1, xc, x2) or not between(y1, yc, y2) then
		exit;

	isect := true;
end;

function count(ang, x11, y11, x12, y12, x21, y21, x22, y22: extended): extended;
var
	xc1, yc1, xc2, yc2: extended;
begin
	assert(isect(ang, x11, y11, x12, y12, xc1, yc1));
	assert(isect(ang, x21, y21, x22, y22, xc2, yc2));
	count := hypot(xc1, yc1) * hypot(xc2, yc2);
end;

function search(x11, y11, x12, y12, x21, y21, x22, y22: extended): extended;
var
	l1, l2, r1, r2, l, r, m: extended;
	tl, tr: extended;
	ang1, ang2: extended;
begin
	ang1 := arctan2(y11, x11);
	ang2 := arctan2(y12, x12);
	l1 := min(ang1, ang2);
	r1 := max(ang1, ang2);
	ang1 := arctan2(y21, x21);
	ang2 := arctan2(y22, x22);
	l2 := min(ang1, ang2);
	r2 := max(ang1, ang2);

	l := max(l1, l2);
	r := min(r1, r2);
	if (r < l + eps) then begin
		search := -1;
		exit;
	end;

	m := (r + l) / 2;
	while (m <> l) and (m <> r) do begin
		tl := count((m + l) / 2, x11, y11, x12, y12, x21, y21, x22, y22);
		tr := count((m + r) / 2, x11, y11, x12, y12, x21, y21, x22, y22);
		if (tl < tr) then
			r := m
		else
			l := m;
		m := (l + r) / 2;
	end;

	search := m;
end;

var
	i, j, n: longint;
	x, y: array [0..maxn + 1] of extended;
	s: extended;
	d: extended;
	xc, yc: extended;
	m: longint;
	test: array [1..maxt] of extended;
	best, min, max: extended;

begin
	reset(input, 'polygon.in');
	rewrite(output, 'polygon.out');

	readln(n);
	assert((3 <= n) and (n <= 100));
	for i := 1 to n do begin
		readln(x[i], y[i]);
		assert(abs(x[i]) <= 1000);
		assert(abs(y[i]) <= 1000);
	end;
	x[0] := x[n];
	y[0] := y[n];
	x[n + 1] := x[1];
	y[n + 1] := y[1];

	s := 0;
	for i := 1 to n do begin
		s := s + (x[i] - x[i - 1]) * (y[i] + y[i - 1]);
	end;
	assert(s < 0);

	s := 0;
	for i := 1 to n do begin
		assert(abs((x[i] - x[i - 1]) * (y[i + 1] - y[i]) - (x[i + 1] - x[i]) * (y[i] - y[i - 1])) > eps);
		assert(abs(x[i] * y[i + 1] - x[i + 1] * y[i]) > eps);
		assert((x[i + 1] - x[i]) * (y[i] - y[i - 1]) - (y[i + 1] - y[i]) * (x[i] - x[i - 1]) < eps);
		s := s + arctan2(x[i + 1] * y[i] - x[i] * y[i + 1], x[i] * x[i + 1] + y[i] * y[i + 1]);
	end;
	assert(abs(s) < eps);

	min := arctan2(y[1], x[1]);
	max := arctan2(y[1], x[1]);
	if max < 0 then max := max + 2 * pi;
	if min < 0 then min := min + 2 * pi;
	for i := 2 to n do begin
		d := arctan2(y[i], x[i]);
		if (d < max - pi) then d := d + 2 * pi;
		if (d < min) then min := d;
		if (d > max) then max := d;
	end;

    if (max - min > pi) then begin
    	min := max;
    end;

    min := min - eps;
    for i := 1 to n do begin
    	xc :=   x[i] * cos(min) + y[i] * sin(min);
    	yc := - x[i] * sin(min) + y[i] * cos(min);
    	x[i] := xc;
    	y[i] := yc;
    end;
	x[0] := x[n];
	y[0] := y[n];
	x[n + 1] := x[1];
	y[n + 1] := y[1];

	m := 0;
	for i := 1 to n do begin
		inc(m);
		test[m] := arctan2(y[i], x[i]);
		assert((test[m] > 0) and (test[m] < pi));
	end;

	for i := 1 to n do begin
		for j := i + 1 to n do begin
			d := search(x[i], y[i], x[i + 1], y[i + 1], x[j], y[j], x[j + 1], y[j + 1]);
			if (d > 0) then begin
    			inc(m);
    			test[m] := d;
    		end;
		end;
	end;

  	best := 1e100;
	for i := 1 to m do begin
		min := 1e100;
		max := 0;
		for j := 1 to n do begin
			if isect(test[i], x[j], y[j], x[j + 1], y[j + 1], xc, yc) then begin
				d := hypot(xc, yc);
				if (d < min) then min := d;
				if (d > max) then max := d;
			end;
		end;

		assert(max >= min);

		if min * max < best then begin
			best := max * min;
		end;
	end;

	writeln(best :0 :10);

	close(input);
	close(output);
end.