#include<bits/stdc++.h>
using std::cin;
using std::cout;
using ll = long long;
using u64 = unsigned long long;
using db = long double;
const db eps = 1e-4;
const db pi = std::acos(-1);
std::mt19937 gen;


db sgn(db x, db eps) { return x < -eps ? -1 : x > eps; }
db sgn(db x) { return x < -eps ? -1 : x > eps; }
db eq(db x, db y) { return !sgn(x - y); }
struct vec2 {
	db x, y;
	db abs() const { return std::sqrt(x * x + y * y); }
};
vec2 r90(vec2 x) { return {-x.y, x.x}; }
vec2 operator + (vec2 x, vec2 y) { return {x.x + y.x, x.y + y.y}; }
vec2 operator - (vec2 x, vec2 y) { return {x.x - y.x, x.y - y.y}; }
vec2 operator / (vec2 x, db y) { return {x.x / y, x.y / y}; }
vec2 operator * (vec2 x, db y) { return {x.x * y, x.y * y}; }
db operator * (vec2 x, vec2 y) { return x.x * y.y - x.y * y.x; }
db operator % (vec2 x, vec2 y) { return x.x * y.x + x.y * y.y; }

struct line : vec2 {
	db z;
	line() = default;
	line(db a, db b, db c) : vec2{a, b}, z(c) {}
	line(vec2 a, vec2 b) : vec2(r90(b - a)), z(a * b) { }
	db operator ()(vec2 a) const { return a % vec2(*this) + z; }
	line perp() const { return {y, -x, 0}; } // 垂直
	line para(vec2 o) { return {x, y, z - (*this)(o)}; } // 平行
	bool test(vec2 o) const {
		using f128 = __float128;
		return (f128) o.x * x + (f128) o.y * y + z >= 0;
	}
};
vec2 operator & (line x, line y) {
	return vec2{vec2{x.z, x.y} * vec2{y.z, y.y}, vec2{x.x, x.z} * vec2{y.x, y.z}} / -(vec2(x) * vec2(y));
}
std::tuple<ll, ll, ll> operator && (line x, line y) {
	ll A = round(vec2{x.z, x.y} * vec2{y.z, y.y} * 4);
	ll B = round(vec2{x.x, x.z} * vec2{y.x, y.z} * 4);
	ll C = round(-(vec2(x) * vec2(y)) * 4);
	if(C < 0) {
		A *= -1;
		B *= -1;
		C *= -1;
	}
	int lg = __builtin_ctzll(A | B | C);
	return std::make_tuple(A >> lg, B >> lg, C >> lg);
}
line bisector(vec2 x, vec2 y) { return line(y, x).perp().para((x + y) / 2); } // x 在半平面一侧
bool is_para(line x, line y) { return eq(vec2(x) * vec2(y), 0); } // 判断线平行
db det(const line & a, const line & b, const line & c) {
	//using f128 = __float128;
	vec2 A = a, B = b, C = c;
	using f128 = db;
	return c.z * f128(A * B) + a.z * f128(B * C) + b.z * f128(C * A);
}
db check(const line & a, const line & b, const line & c) {
	return sgn(det(a, b, c), 0.25) * sgn(vec2(a) * vec2(b));
}
struct seg {
	vec2 x, y;
	seg(const vec2 & A, const vec2 & B) : x(A), y(B) {}
	bool onseg(const vec2 & o) const {
		return (o - x) % (o - y) < eps && std::fabs((o - x) * (o - y)) < eps;
	}
};
int contain(const std::vector<vec2> & a, vec2 o) {
	bool in = 0;
	for(int i = 0;i < (int) a.size();++i) {
		vec2 x = a[i] - o, y = a[(i + 1) % a.size()] - o;
		if(x.y > y.y) std::swap(x, y);
		if(x.y <= eps && y.y > eps && x * y < -eps) in ^= 1;
		if(std::fabs(x * y) < eps && x % y < eps) return 2; // 在线段上，看情况改
	}
	return in;
}
std::vector<line> cut(const std::vector<line> & o, line l) {
	std::vector<line> res;
	int n = size(o);
	for(int i = 0;i < n;++i) {
		line a = o[i], b = o[(i + 1) % n], c = o[(i + 2) % n];
		int va = check(a, b, l), vb = check(b, c, l);
	//	assert(check(a, b, c) != 0);
		if(va > 0 || vb > 0 || (va == 0 && vb == 0)) {
			res.push_back(b);
		}
		if(va >= 0 && vb < 0) {
			res.push_back(l);
		}
	}
	return res;
}
const db V = 1e9;
std::vector<std::vector<line>> voronoi(std::vector<vec2> p) {
	int n = p.size();
	auto b = p; shuffle(b.begin(), b.end(), gen);
	std::vector<std::vector<line>> a(n, {
		
		{1, 0, V}, {-1, 1, 2 * V},
			{-1, -1, 2 * V},
	});
	for(int i = 0;i < n;++i) {
		for(vec2 x : b) if((x - p[i]).abs() > eps) {
			a[i] = cut(a[i], bisector(p[i], x));
		}
	}
	return a;
}
std::vector<std::vector<line>> negvoronoi(std::vector<vec2> p) {
	int n = p.size();
	auto b = p; shuffle(b.begin(), b.end(), gen);
	std::vector<std::vector<line>> a(n, {
		{1, 0, V}, {-1, 1, 2 * V},
			{-1, -1, 2 * V},
	});
	for(int i = 0;i < n;++i) {
		for(vec2 x : b) if((x - p[i]).abs() > eps) {
			a[i] = cut(a[i], bisector(x, p[i]));
			if(a[i].empty()) break;
		}
	}
	return a;
}
std::vector<vec2> gethull(std::vector<vec2> o) { 
	sort(o.begin(), o.end(), [](vec2 x, vec2 y) { return eq(x.x, y.x) ? x.y < y.y : x.x < y.x; });
	std::vector<vec2> stack;
	auto cross = [&](vec2 a, vec2 b, vec2 c) {
		return (b - a) * (c - a);
	};
	for(int i = 0;i < (int) o.size();++i) {
		for(;stack.size() >= 2 && cross(stack.rbegin()[1], stack.back(), o[i]) <= eps;) {
			stack.pop_back();
		}
		stack.push_back(o[i]);
	}
	for(int i = o.size() - 2, t = stack.size();i >= 0;--i) {
		for(;stack.size() > t && cross(stack.rbegin()[1], stack.back(), o[i]) <= eps;) {
			stack.pop_back();
		}
		stack.push_back(o[i]);
	}
	stack.pop_back();
	return stack;
}
db findmax(vec2 d, const std::vector<vec2> & a) {
	int l = 0, r = a.size() - 1;
	if(a[0] % d > a.back() % d) {
		for(;l + 1 < r;) {
			int mid = (l + r) >> 1;
			if(a[mid] % d > a[l] % d && a[mid] % d > a[mid - 1] % d) {
				l = mid;
			} else {
				r = mid;
			}
		}
		return l;
	} else {
		for(;l + 1 < r;) {
			int mid = (l + r) >> 1;
			if(a[mid] % d > a[r] % d && a[mid] % d > a[mid + 1] % d) {
				r = mid;
			} else {
				l = mid;
			}
		}
		return r;
	}
} // 完整凸包二分求极值


int main() {
#ifdef zqj
	freopen("$.in", "r", stdin);
#endif
	std::ios::sync_with_stdio(false), cin.tie(0);
	int n;
	n = 3000;
	cin >> n;
	std::mt19937 gen(142);

	std::vector<vec2> a(n);
	for(int i = 0;i < n;++i) {
//		a[i].x = gen() %  100000 + 1;
//		a[i].y = gen() %  100000 + 1;
		cin >> a[i].x >> a[i].y;
	}
	auto vd0 = voronoi(a);
	std::cerr << double(clock()) / CLOCKS_PER_SEC << '\n';
	auto vd1 = negvoronoi(a);
	std::cerr << double(clock()) / CLOCKS_PER_SEC << '\n';
	db ans = 1e18, r = 0;
	ll x = 0, y = 0, z = 1;
	int is_line = 1;
	auto b = gethull(a);
	for(int i = 0;i < (int) b.size();++i)
		for(int j = 0;j < i;++j) {
			vec2 t = r90(b[j] - b[i]), negt = vec2{} - t;
			int A = findmax(t, b);
			int B = findmax(negt, b);
			db v = (b[A] - b[B]) % t / t.abs();
			v /= 2;
			if(v < ans) {
				ans = v;
				x = round(t.x * 2);
				y = round(t.y * 2);
				z = round(t % (b[A] + b[B]));
			}
		}

	for(int i = 0;i < n;++i) if(vd1[i].size()) {
		for(int j = 0;j < n;++j) {
			auto tmp = vd1[i];
			for(auto t : vd0[j]) {
				tmp = cut(tmp, t);
				if(!tmp.size()) break;
			}
			auto judge = [&](line A, line B) {
				if(fabs(A * B) <= 0.1) return ;
				vec2 X = A & B;
				if(X.abs() >= V) {
					X = {(ll) X.x, (ll) X.y};
				}
				db d1 = (X - a[i]).abs();
				db d0 = (X - a[j]).abs();
				for(int k = 0;k < n;++k) {
					d1 = std::max(d1, (X - a[k]).abs());
					d0 = std::min(d0, (X - a[k]).abs());
				}
				db val = std::abs((d1 - d0) / 2);
				if(val < ans) {
					ans = val;
					r = (d0 + d1) / 2;
					is_line = 0;
					if(X.abs() >= V) {
						x = X.x;
						y = X.y;
						z = 1;
					} else {
						std::tie(x, y, z) = A && B;
					}
				}
			};
			if(tmp.size()) {
				for(int k = 0;k < (int) tmp.size();++k) {
					line a = tmp[k], b = tmp[(k + 1) % tmp.size()];
					judge(a, b);
				}
			}
		}
	}
	std::cerr << double(clock()) / CLOCKS_PER_SEC << '\n';
	printf("%.10Lf\n", std::max(ans + 1e-7, ans * (1 + 1e-7)));
	if(is_line) {
		printf("L %lld %lld %lld\n", x, y, z);
	} else {
		printf("C %lld %lld %lld %.10Lf\n", x, y, z, r);
	}
}