/*
TASK: atom
LANG: C++
*/

#include <iostream>
#include <iomanip>
#include <fstream>
#include <vector>
#include <algorithm>
#include <math.h>

using namespace std;

#define eps 1e-9
#define MAXN 256
#define PB push_back
#define abs(x) ((x)<0?(-(x)):(x))

// just double *may* be not sufficient
typedef long double real;

// compare with threshold
static inline bool eq(real x, real y)
{
	return (fabs(x-y) < eps);
}

// Coord and vector class
struct coord {
	real x, y;
	coord() {}
	coord(real a, real b): x(a),y(b){}
	bool operator < (const coord & r) const
	{
		if (r.y != y) return y < r.y;
		return x < r.x;
	}
	coord(const coord & a, const coord & b) // vector from b to a
	{
		x = a.x - b.x;
		y = a.y - b.y;
	}
	real length(void)
	{
		return sqrt(x*x+y*y);
	}
	void norm(void)
	{
		real l = 1.0/length();
		x *= l;
		y *= l;
	}
	coord operator +(const coord & r) const
	{
		return coord(x + r.x, y + r.y);
	}
	coord operator *(real m) const
	{
		return coord(x*m, y*m);
	}
	void rot90(void)
	{
		real x1 = x;
		real y1 = y;
		x = -y1;
		y = +x1;
	}
	void print(void) const
	{
		cerr << "(" << x << ", " << y << ")";
	}
};

int n;			//number of points
real city_area;		//the area of the country
coord p[MAXN];		//the points
vector<int> hull;	//indexing array, that contains the convex hull
coord probe_point;	//the point, where it is best to place the VIP bunker
real ans;		//the answer to the task

// Directed area
real face(const coord& a, const coord& b, const coord& c)
{
	return	+ a.x  * b.y  + b.x  * c.y  + c.x  * a.y
		- c.x  * b.y  - b.x  * a.y  - a.x  * c.y;
}

// Computes the convex hull
void make_hull(void)
{
	vector<int> l, r;
	sort(p, p + n);
	l.PB(0);
	l.PB(1);
	r = l;
	for (int i = 2; i < n; i++) {
		l.PB(i); r.PB(i);
		while (l.size() > 2 && face(p[l[l.size()-3]], p[l[l.size()-2]], p[l[l.size()-1]]) > 0)
			l.erase(l.end()-2);
		while (r.size() > 2 && face(p[r[r.size()-3]], p[r[r.size()-2]], p[r[r.size()-1]]) < 0)
			r.erase(r.end()-2);
	}
	hull = r;
	for (unsigned i = l.size()-2; i > 0; i--)
		hull.PB(l[i]);
	city_area = 0;
	for (unsigned i = 1; i < hull.size()-1; i++)
		city_area += abs(face(p[hull[0]], p[hull[i]], p[hull[i+1]]));
}

// Find the intersection of circles with centers a and b, radius R.
// store the intersecions in res, returning the number of intersections
int cross(const coord & a, const coord & b, real R, coord *res)
{
	coord dt(b, a);
	real d = dt.length()*0.5;
	if (d > R) return 0;
	real h = sqrt(R*R-d*d);
	dt.norm(); dt.rot90();
	coord c(0.5*(a.x + b.x), 0.5*(a.y + b.y));
	res[0] = c + dt * h;
	res[1] = c + dt * (-1.0*h);
	return 2;
}

// Find the intersection of a circle a with radius R with the 
// line segment AB. Store the intersections in res, returning their count
int cross(const coord & aa, const coord & A, const coord & B, real R, coord *res)
{
	coord v(B, A);
	coord h(A, aa);
	real b = 2*(h.x * v.x + h.y * v.y);
	real a = v.x*v.x + v.y*v.y;
	real c = h.x*h.x + h.y*h.y - R*R;
	real D = b*b - 4*a*c;
	//cout << a << " " << b << " " << c << " " << D << endl;
	if (D < 0) return 0;
	D = sqrt(D);
	int cnt = 0;
	real p1 = (-b + D)/(2*a);
	real p2 = (-b - D)/(2*a);
	if (p1 >= 0 && p1 <= 1)	res[cnt++] = A + v*p1;
	if (p2 >= 0 && p2 <= 1)	res[cnt++] = A + v*p2;
	return cnt;
}

// Checks if the given point is within the country limits
bool in_city(const coord & pt)
{
	real area = 0.0;
	for (unsigned i = 0; i < hull.size(); i++)
		area += abs(face(pt, p[hull[i]], p[hull[(i+1)%hull.size()]]));
	return eq(area, city_area);
}


// Checks if the given point is outside any circle
bool outside_any(const coord & pt, real R)
{
	for (int i = 0; i < n; i++) {
		coord t(pt, p[i]);
		real l = t.length();
		if (!eq(l, R) && (l < R)) return false;
	}
	return true;
}
// Checks if a particular radius R is too large or too small to fullfill the
// desired optima. Returns true if it is too small and false otherwise
bool probe(real R)
{
	bool crossing = false;
	for (int i = 0; i < n; i++) {
		for (int j = i+1; j < n; j++) {
			coord a[2];
			if (cross(p[i], p[j], R, a)) {
				crossing = true;
				for (int k = 0; k < 2; k++) {
					if (in_city(a[k]) && outside_any(a[k], R)) {
						probe_point = a[k];
						return true;
					}
				}
			}
		}
		for (unsigned j = 0; j < hull.size(); j++) {
			coord p1 = p[hull[j]];
			coord p2 = p[hull[(j+1)%hull.size()]];
			coord a[2];
			int r = cross(p[i], p1, p2, R, a);
			for (int k = 0; k < r; k++) {
				crossing = true;
				if (in_city(a[k]) && outside_any(a[k], R)) {
					probe_point = a[k];
					return true;
				}
			}
		}
	}
	return false;
}

// Solve the task: perform binary search
void solve(void)
{
	real l = 0.0, r = 40000.0;
	while (r - l > 1e-5) {
		real m = (r+l)*0.5;
		if (probe(m))
			l = m;
		else
			r = m;
	}
	ans = (l+r)*0.5;
}

// Write out an .vis file for optional display of the test case and answer.
void output_vis(void)
{
	ofstream f("example.vis");
	f << setiosflags(ios::fixed) << setprecision(6);
	for (int i = 0; i < n; i++)
		f << "p " << p[i].x << " " << p[i].y << endl;
	for (unsigned i = 0; i < hull.size(); i++) {
		f << "l " << hull[i] << " " << hull[(i+1) % hull.size()] << endl;
	}
	f << "c " << probe_point.x << " " << probe_point.y << " " << ans << endl;
}

int main(void)
{
	cin >> n;
	for (int i = 0; i < n; i++) {
		cin >> p[i].x >> p[i].y;
	}
	make_hull();
	solve();
	cout << setiosflags(ios::fixed) << setprecision(2) << ans << endl;
	cout << probe_point.x << " " << probe_point.y << endl;
	output_vis();
	return 0;
}
