qwq

#include<bits/stdc++.h>
#define IL inline
#define _ 100005
#define ll long long
using namespace std ;

IL int gi(){
    int data = 0 , m = 1; char ch = 0;
    while(ch!='-' && (ch<'0'||ch>'9')) ch = getchar();
    if(ch == '-'){m = 0 ; ch = getchar() ; }
    while(ch >= '0' && ch <= '9'){data = (data<<1) + (data<<3) + (ch^48) ; ch = getchar(); }
    return (m) ? data : -data ; 
}

#define ld long double
#define inf 1e9
#define eps 1e-6
int n ; 

const ld PI = acos(-1.0) ;

struct Point{
	ld x , y ;
	IL Point(){x = 0 ; y = 0 ; }
	IL Point(double a , double b){x = a ; y = b ; }
	IL ld cal() {return sqrt(x*x + y*y) ; }
	IL void Print(){printf("(%Lf,%Lf)" , x , y) ; }
} ;

IL Point operator + (Point a , Point b) {return Point(a.x + b.x , a.y + b.y) ; }
IL Point operator - (Point a , Point b) {return Point(a.x - b.x , a.y - b.y) ; }
IL ld operator ^ (Point a , Point b) {return a.x * b.x + a.y * b.y ; }
IL ld operator * (Point a , Point b) {return a.x * b.y - a.y * b.x ; }
IL Point operator * (Point a , double b) {return Point(a.x * b , a.y * b) ; }

IL ld Sqr(ld x) {return 1.0 * x * x ; }
IL ld Dist(Point a , Point b) {return sqrt(Sqr(a.x - b.x) + Sqr(a.y - b.y)) ; }
IL Point Rot(Point a , ld Arc) {
	return Point(cos(Arc)*a.x - sin(Arc)*a.y , sin(Arc)*a.x + cos(Arc)*a.y) ; 
}

struct Line {
	Point p1 , p2 ;
	IL Line() {p1 = Point() ; p2 = Point() ; }
	IL Line(Point a , Point b) {p1 = a ; p2 = b ; }
	IL void Print(){p1.Print() ; putchar('-') ; putchar('-') ; putchar('>') ; p2.Print() ; }
} ;

IL Line Perp(Line A) {
	Point a = A.p1 , b = A.p2 , c ;
	c = b - a ;
	c = Rot(c , PI * 0.5) ;
	return Line((a + b) * 0.5 , ((a + b) * 0.5) + c * 0.5) ; 
}
IL Point GetCross(Line l1 , Line l2) {
	Point a = l1.p2 - l1.p1 , b = l2.p2 - l2.p1 , c = l2.p1 - l1.p1 ;
	ld al = (a * c) / (b * a) ; 
	return Point(l2.p1.x + b.x * al , l2.p1.y + b.y * al) ;
}
IL ld Dist(Line l1 , Point ps) {
	Point w = l1.p2 - l1.p1 ;
	return fabs(w * (ps - l1.p1)) / Dist(l1.p1 , l1.p2) ;
}

Point p[_] , circle_p ;
ld circle_range ; 

namespace CirCle{
	IL void Print_Circle() {
		printf("%.8Lf %.8Lf %.8Lf
" , circle_p.x , circle_p.y , circle_range) ;
		return ; 
	}
	IL void main() {
		random_shuffle(p + 1 , p + n + 1) ; random_shuffle(p + 1 , p + n + 1) ;
		circle_p = p[1] ; circle_range = 0 ;
		for(int i = 2; i <= n; i ++)
			if(Dist(circle_p , p[i]) > circle_range) {
				circle_p = p[i] ; circle_range = 0 ;
				for(int j = 1; j < i; j ++)
					if(Dist(circle_p , p[j]) > circle_range) {
						circle_p = (p[i] + p[j]) * 0.5 ; circle_range = Dist(circle_p , p[i]) ;
						for(int k = 1; k < j; k ++)
							if(Dist(circle_p , p[k]) > circle_range) {
								Line l1 , l2 ;
								l1 = Line(p[k] , p[j]) ; l2 = Line(p[i] , p[j]) ;	
								l1 = Perp(l1) ;
								l2 = Perp(l2) ;
								circle_p = GetCross(l1 , l2) ; circle_range = Dist(circle_p , p[i]) ;
							}
					}
			}
		Print_Circle() ; 
	}
}

Point Base_p , gm[_] ; int nG , tot ;

namespace GraHam{
	IL bool cmp_GraHam(Point a , Point b) {
		return (a - Base_p) * (b - Base_p) > 0 ; 
	}
	IL void Print_GraHam() {
		for(int i = 0; i <= nG; i ++) {
			gm[i].Print() ; putchar('-') ; putchar('-') ; putchar('>') ; 
		}
		puts("") ; return ;
	}
	IL void main() {
		nG = 0 ;
		Base_p = p[1] ; int id = 1 ; 
		for(int i = 2; i <= n; i ++) if(p[i].x < Base_p.x || (fabs(p[i].x-Base_p.x)<=eps && p[i].y < Base_p.y)) Base_p = p[i] , id = i ;
		tot = 0 ;
		for(int i = 1; i <= n; i ++) if(id != i) p[++tot] = p[i] ; n = tot ; 
		sort(p + 1 , p + n + 1 , cmp_GraHam) ;
		gm[nG = 0] = Base_p ;
		gm[++ nG] = p[1] ; 
		for(int i = 2; i <= n; i ++) {
			while(nG >= 1 && (p[i] - gm[nG - 1]) * (gm[nG] - gm[nG -1]) > 0) -- nG ;
			gm[++nG] = p[i] ;
		}
		//Print_GraHam() ; return ; 
	}
}

Point tmp_matrix[10] , matrix_p[10] ;

namespace Matrix{
	IL bool cmp_Sort_Matrix(Point a , Point b) {
		return (a - matrix_p[0]) * (b - matrix_p[0]) >= 0 ; 
	}
	IL void Print_Matrix() {
		Point w = tmp_matrix[1] - tmp_matrix[0] , delta ;
		double l , l1 , l2 , l3 ;
		l = Dist(tmp_matrix[0] , tmp_matrix[1]) ;
		l2 = (w ^ (tmp_matrix[2] - tmp_matrix[0])) / l ; delta = w * (l2 / l) ;
		matrix_p[1] = tmp_matrix[0] + delta ;
		l1 = (w ^ (tmp_matrix[4] - tmp_matrix[0])) / l ; delta = w * (l1 / l) ;
		matrix_p[0] = tmp_matrix[0] + delta ;
		Point up = w ; up = Rot(w , PI * 0.5) ; l3 = up.cal() ;
		l = Dist(Line(tmp_matrix[0] , tmp_matrix[1]) , tmp_matrix[3]) ; 
		up = up * (l / l3) ;
		matrix_p[2] = matrix_p[1] + up ;
		matrix_p[3] = matrix_p[0] + up ;
		int id = 0 ;
		for(int i = 1; i <= 3; i ++)
			if(matrix_p[i].x < matrix_p[id].x) id = i ;
			else if(fabs(matrix_p[i].x - matrix_p[id].x) <= eps && matrix_p[i].y < matrix_p[id].y) id = i ;
		swap(matrix_p[id] , matrix_p[0]) ;
		sort(matrix_p + 1 , matrix_p + 3 + 1 , cmp_Sort_Matrix) ; 
		for(int i = 0; i <= 3; i ++)
			printf("%.8Lf %.8Lf " , matrix_p[i].x , matrix_p[i].y) ;
		puts("") ;
		return ; 
	}
	IL void main() {
		ld now_C = 1e9 ;
		++ nG ; 
		for(int i = 0,lft,rg = 1,up = 2; i < nG; i ++) {
			Point w = gm[(i+1)%nG] - gm[i] ;
			while(w * (gm[up] - gm[i]) <= w * (gm[(up+1)%nG] - gm[i])) up = (up + 1) % nG ;
			if(i == 0) lft = up ;
			while((w ^ (gm[rg] - gm[i])) - eps <= (w ^ (gm[(rg+1)%nG] - gm[i]))) rg = (rg + 1) % nG ;
			while((w ^ (gm[lft] - gm[i])) + eps >= (w ^ (gm[(lft+1)%nG] - gm[i]))) lft = (lft + 1) % nG ;
			ld al = 0.0 , bh ;
			bh = Dist(Line(gm[i] , gm[(i+1)%nG]) , gm[up]) ;
			al += fabs((w ^ (gm[rg] - gm[i]))) ;
			al += fabs((w ^ (gm[lft] - gm[i]))) ;
			al /= Dist(gm[i] , gm[(i+1) % nG]) ;
			if(2.0 * (al + bh) < now_C) {
				tmp_matrix[0] = gm[i] , tmp_matrix[1] = gm[(i+1)%nG] , tmp_matrix[2] = gm[lft] ;
				tmp_matrix[3] = gm[up] , tmp_matrix[4] = gm[rg] ;
				now_C = 2.0 * (al + bh) ;
			}
		}
		-- nG ; 
		Print_Matrix() ; return ; 
	}
}

Point tmp_triange[10] , triange_p[10] ;
namespace Triange{
	IL ld Calc_right(Point a , Point w , Point c , double lw) {
		ld d = (w ^ (c - a)) / lw , h = Dist(Line(a , a + w) , c) ;
		return h / sqrt(3.0) + d ; 
	}
	IL ld Calc_left(Point a , Point w , Point c , double lw) {
		ld d = (w ^ (c - a)) / lw , h = Dist(Line(a , a + w) , c) ;
		return - h / sqrt(3.0) + d ; 
	}
	IL bool cmp_Sort_Triange(Point a , Point b) {
		return (a - triange_p[0]) * (b - triange_p[0]) >= 0 ; 
	}
	IL void Print_Triange() {
		ld l1 , l2 , l = Dist(tmp_triange[0] , tmp_triange[1]) , lg ;
		Point w = tmp_triange[1] - tmp_triange[0] , delta ;
		l1 = Calc_right(tmp_triange[0] , w , tmp_triange[2] , l) ;
		triange_p[1] = tmp_triange[0] + w * (l1 / l) ;
		l2 = Calc_left(tmp_triange[0] , w , tmp_triange[3] , l) ;
		triange_p[0] = tmp_triange[0] + w * (l2 / l) ;
		lg = fabs(l1) + fabs(l2) ;
		Line al0 , al1 ;
		delta = Rot(w , PI / 3.0) ; al0 = Line(triange_p[0] , triange_p[0] + delta * (lg / l)) ;
		delta = Rot(delta , PI / 3.0) ; al1 = Line(triange_p[1] , triange_p[1] + delta * (lg / l)) ;
		triange_p[2] = GetCross(al0 , al1) ;
		int id = 0 ;
		for(int i = 1; i <= 2; i ++)
			if(triange_p[i].x < triange_p[id].x) id = i ;
			else if(fabs(triange_p[i].x - triange_p[id].x) <= eps && triange_p[i].y < triange_p[id].y) id = i ;
		swap(triange_p[id] , triange_p[0]) ;
		sort(triange_p + 1 , triange_p + 2 + 1 , cmp_Sort_Triange) ;
		for(int i = 0; i <= 2; i ++)
			printf("%.8Lf %.8Lf " , triange_p[i].x , triange_p[i].y) ;
		puts("") ; return ; 
 	}
	IL void main() {
		ld now_C = 1e9 , al ;
		++ nG ;
		for(int i = 0,lft = 1 , rgt = 1,up = 1; i < nG; i ++) {
			Point w = gm[(i+1)%nG] - gm[i] ; ld lw = Dist(gm[(i+1)%nG] , gm[i]) ;
			while(w * (gm[up] - gm[i]) <= w * (gm[(up+1)%nG] - gm[i])) up = (up + 1) % nG ;
			if(i == 0) lft = up ;
			while(Calc_right(gm[i] , w , gm[rgt] , lw) - eps <= Calc_right(gm[i] , w , gm[(rgt+1)%nG] , lw)) rgt = (rgt + 1) % nG ;
			while(Calc_left(gm[i] , w , gm[lft] , lw) + eps >= Calc_left(gm[i] , w , gm[(lft+1)%nG] , lw)) lft = (lft + 1) % nG ;
			al = 0.0 ;
			al += fabs(Calc_left(gm[i] , w , gm[lft] , lw)) ;
			al += fabs(Calc_right(gm[i] , w , gm[rgt] , lw)) ;
			if(3.0 * al <= now_C) {
				tmp_triange[0] = gm[i] ; tmp_triange[1] = gm[(i+1) % nG] ; tmp_triange[2] = gm[rgt] ; tmp_triange[3] = gm[lft] ;
				now_C = 3.0 * al ; 
			}
		}
		-- nG ; 
		Print_Triange() ; return ; 
	}
}

Point gc[_] , tmp_gc[_] ; int nC ; 
namespace Divide_Cut{
	IL void Print_Divide_Cut() {
		for(int i = 1; i <= nC; i ++) {
			gc[i].Print() ; putchar('-') ; putchar('-') ; putchar('>') ; 
		}
		puts("") ; return ;
	}
	IL void Cut(Point a , Point b) {
		gc[nC + 1] = gc[1] ;
		tot = 0;  Point w = b - a ;
		for(int i = 1; i <= nC; i ++) {
			ld test1 = (a - gc[i]) * (b - gc[i]) ;
			if(test1 >= 0.0) tmp_gc[++tot] = gc[i] ;
			ld test2 = (a - gc[i+1]) * (b - gc[i+1]) ;
			if(test2 * test1 < 0) tmp_gc[++tot] = GetCross(Line(a , b) , Line(gc[i] , gc[i + 1])) ;
		}
		for(int i = 1; i <= tot; i ++) gc[i] = tmp_gc[i] ;
		nC = tot ; 
	}
	IL void main() {
		gc[++nC] = Point(-inf,-inf) ;
		gc[++nC] = Point(inf,-inf) ;
		gc[++nC] = Point(inf,inf) ;
		gc[++nC] = Point(-inf,inf) ; 
		for(int i = 0; i <= 3; i ++) {
			Cut(matrix_p[i] , matrix_p[(i+1)%4]) ;
		}
		for(int i = 0; i <= 2; i ++) Cut(triange_p[i] , triange_p[(i+1)%3]) ;
		//Print_Divide_Cut() ; 
		return ; 
	}
}

ld circle_pl , circle_pr , polygon_pl , polygon_pr , Ans ;
namespace Simpson_Int{
	IL ld F(ld x) {
		if(!(circle_p.x - circle_range - eps <= x && x <= circle_p.x + circle_range + eps)) return 0 ;
		ld d = sqrt(Sqr(circle_range) - Sqr(fabs(x - circle_p.x))) ;
		circle_pl = circle_p.y - d ; circle_pr = circle_p.y + d ;
		polygon_pl = inf ; polygon_pr = -inf ;
		tot = 0 ;
		for(int i = 1; i <= nC; i ++)
			if((gc[i].x - eps <= x && gc[i%nC + 1].x + eps >= x) || (gc[i%nC + 1].x - eps <= x && gc[i].x + eps >= x)  ) {
				Point al = GetCross(Line(gc[i] , gc[i%nC+1]) , Line(Point(x,0) , Point(x,1))) ;
				polygon_pl = min(polygon_pl , al.y) ;
				polygon_pr = max(polygon_pr , al.y) ;
			}
		//cout << "circle: ["<<circle_pl<<","<<circle_pr<<"]" << endl ;
		//cout << "polygon: ["<< polygon_pl<<","<<polygon_pr<<"]" << endl ; 
		if(polygon_pl >= polygon_pr) return 0 ;
		ld pl , pr ;
		pl = max(circle_pl , polygon_pl) ;
		pr = min(circle_pr , polygon_pr) ;
		if(pl - eps <= pr) return pr - pl ; else return 0 ; 
	}
	ld Calc(ld l , ld r) {return (r-l) * (F(l) + F(r) + 4.0 * F((l + r) * 0.5)) / 6.0 ; }
	ld Simpson(ld l , ld r , ld ans) {
		ld mid = (l + r) * 0.5 ;
		ld x1 = Calc(l , mid) , x2 = Calc(mid , r) ;
		ld al = x1 + x2 ;
		if(fabs(al - ans) <= 1e-12) return al ;
		return Simpson(l , mid , x1) + Simpson(mid , r , x2) ;
	}
	IL void main() {
		ld pl = circle_p.x - circle_range ;
		ld pr = circle_p.x + circle_range ;
		for(int i = 1; i <= nC; i ++) {
			pl = min(pl , gc[i].x) ;
			pr = max(pr , gc[i].x) ;
		}
		Ans = Simpson(pl , pr , Calc(pl , pr)) ;
		printf("%.8Lf
" , Ans) ;
		return ;
	}
}

int main() {
	freopen("adieu.in","r",stdin) ;
	freopen("adieu.out","w",stdout) ;
	n = gi() ;
	for(int i = 1; i <= n; i ++) scanf("%Lf %Lf" , &p[i].x , &p[i].y) ;
	CirCle::main() ;
	GraHam::main() ; 
	Matrix::main() ;
	Triange::main() ;
	Divide_Cut::main() ;
	Simpson_Int::main() ; 
	return 0 ;
}