// what is matter? never mind. 
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
//#pragma GCC target("sse,sse2,sse3,sse4,popcnt,abm,mmx,avx,avx2")
#include<bits/stdc++.h>
#define For(i,a,b) for(int i=(a);i<=(b);++i)
#define Rep(i,a,b) for(int i=(a);i>=(b);--i)
#define ll long long
#define ull unsigned long long
#define int long long
#define SZ(x) ((int)((x).size()))
#define ALL(x) (x).begin(),(x).end()
using namespace std;
inline int read()
{
	char c=getchar();int x=0;bool f=0;
	for(;!isdigit(c);c=getchar())f^=!(c^45);
	for(;isdigit(c);c=getchar())x=(x<<1)+(x<<3)+(c^48);
	return f?-x:x;
}

#define fi first
#define se second
#define pb push_back
#define mkp make_pair
typedef pair<int,int>pii;
typedef vector<int>vi;

typedef long double db;
const db eps=1e-5,pi=3.14159265358979323846;
int sgn(db x){return x<-eps?-1:x>eps;}
int cmp(db a,db b){return sgn(a-b);}

struct P{
	db x,y; int id;
	P(db x=0,db y=0):x(x),y(y){}
	P&operator +=(P o){return x+=o.x,y+=o.y,*this;}
	P&operator -=(P o){return x-=o.x,y-=o.y,*this;}
	P&operator *=(db o){return x*=o,y*=o,*this;}
	P&operator /=(db o){return x/=o,y/=o,*this;}
	friend P operator +(P a,P b){return a+=b;}
	friend P operator -(P a,P b){return a-=b;}
	friend P operator *(P a,db b){return a*=b;}
	friend P operator /(P a,db b){return a/=b;}
	friend bool operator <(P a,P b){return fabs(a.x-b.x)<eps?a.y<b.y:a.x<b.x;}
	friend bool operator ==(P a,P b){return cmp(a.x,b.x)==0 && cmp(a.y,b.y)==0;}
	friend bool operator !=(P a,P b){return !(a==b);}
	friend db operator %(P a,P b){return a.x*b.x+a.y*b.y;} // dot
	friend db operator *(P a,P b){return a.x*b.y-a.y*b.x;} // cross
	
	P rot(db o){
		db s=sin(o),c=cos(o);
		return P(x*c-y*s,x*s+y*c);
	}
	P rot90(){return P(-y,x);}
	db ang(){return atan2(y,x);}
	db len(){return sqrt(x*x+y*y);}
	db len2(){return x*x+y*y;}
	
	int half(){return sgn(y)==1||(sgn(y)==0&&sgn(x)>=0);}
	P unit(){return ((*this))/len();}
	
	void read(){cin>>x>>y;}
	void out(){cout<<"("<<x<<","<<y<<")"<<endl;}
};
bool cmp_dir(P a,P b){
	if(a.half()!=b.half())return a.half()<b.half();
	return sgn(a*b)>0;
}

db dis(P a,P b){return (a-b).len();}
db cross(P a,P b,P c){
	// (a->b)*(a->c)
	return (b.x-a.x)*(c.y-a.y)-(b.y-a.y)*(c.x-a.x);
}
int cmp3(P a,P b,P c){
	return sgn(cross(a,b,c));
}

bool in_tri(P a,P b,P c,P p){
	if(cmp3(a,b,c)<0) swap(b,c);
	return cmp3(a,b,p)>=0 && cmp3(b,c,p)>=0 && cmp3(c,a,p)>=0;
}
db area_tri(P a,P b,P c){
	return fabs(cross(a,b,c))/2;
}

bool paral(P p1,P p2,P q1,P q2){
	// is parallel
	return sgn((p2-p1)*(q2-q1))==0;
}
P interl(P p1,P p2,P q1,P q2){
	// intersect point
	db s1=cross(q1,q2,p1),s2=-cross(q1,q2,p2);
	return (p1*s2+p2*s1)/(s1+s2);
}

bool inter(db l1,db r1,db l2,db r2){
	if(l1>r1)swap(l1,r1); if(l2>r2)swap(l2,r2);
	return !(cmp(r1,l2)==-1||cmp(r2,l1)==-1);
}
bool ismid(db a,db m,db b){
	return sgn(a-m)==0||sgn(b-m)==0||((a<m)!=(b<m));
}
bool ismid(P a,P m,P b){
	return ismid(a.x,m.x,b.x)&&ismid(a.y,m.y,b.y);
}

bool isseg(P p1,P p2,P q1,P q2){
	return inter(p1.x,p2.x,q1.x,q2.x) && inter(p1.y,p2.y,q1.y,q2.y) &&
	cmp3(p1,p2,q1)*cmp3(p1,p2,q2)<=0 && cmp3(q1,q2,p1)*cmp3(q1,q2,p2)<=0;
}
bool isseg_strict(P p1,P p2,P q1,P q2){
	return cmp3(p1,p2,q1)*cmp3(p1,p2,q2)<0 && cmp3(q1,q2,p1)*cmp3(q1,q2,p2)<0;
}

struct L{
	P a,b; int id;
	L(P aa=P(0,0),P bb=P(0,0)){a=aa,b=bb;}
	bool in(P p){return sgn((b-a)*(p-a))>0;}
	int in_sgn(P p){return sgn((b-a)*(p-a));}
	P dir(){return b-a;}
	bool onl(P p){
		return cmp3(a,b,p)==0;
	}
	bool onseg(P p){
		return onl(p)&&ismid(a,p,b);
	}
	bool onseg_strict(P p){
		return onl(p)&&sgn((p-a)%(a-b))*sgn((p-b)%(a-b))<0;
	}
	void out(){cout<<"("<<a.x<<","<<a.y<<")---("<<b.x<<","<<b.y<<")\n";}
};

bool isseg(L a,L b){
	return isseg(a.a,a.b,b.a,b.b);
}
bool paral(L a,L b){
	// is parallel
	return paral(a.a,a.b,b.a,b.b);
}
P operator &(L a,L b){
	return interl(a.a,a.b,b.a,b.b);
}
bool samedir(L a,L b){
	return paral(a,b) && sgn(a.dir()%b.dir())==1;
}
bool operator <(L a,L b){
	if(samedir(a,b)) return b.in(a.a);
	return cmp_dir(a.dir(),b.dir());
}

P proj(L a,P b){
	P d=a.dir();
	return a.a+d*((d%(b-a.a))/d.len2());
}
P reflect(L a,P b){
	return proj(a,b)*2-b;
}
db dis(L a,P b){
	db s=abs((b-a.a)*(b-a.b));
	return s/dis(a.a,a.b);
}
db dis_seg(L a,P b){
	if(a.a==a.b) return	dis(a.a,b);
	P h=proj(a,b);
	if(ismid(a.a,h,a.b)) return dis(h,b);
	return min(dis(a.a,b),dis(a.b,b));
}

db rad(P a,P b){
	return atan2l(a*b,a%b);
}

// polygon
db area(vector<P>a){
	db res=0;
	For(i,0,(int)a.size()-1)res+=a[i]*a[(i+1)%a.size()];
	return res/2;
}
int contain(vector<P>a,P p){
	int n=a.size(),res=0;
	For(i,0,n-1){
		P u=a[i],v=a[(i+1)%n];
		if(L(u,v).onseg(p))return 1;
		if(cmp(u.y,v.y)<=0)swap(u,v);
		if(cmp(p.y,u.y)>0 || cmp(p.y,v.y)<=0)continue;
		res^=cmp3(p,u,v)>0;
	}
	return res*2;
}
vector<P>cut(vector<P>&a,P q1,P q2){
	vector<P>b; int n=a.size();
	For(i,0,n-1){
		P p1=a[i],p2=a[(i+1)%n];
		int d1=cmp3(q1,q2,p1),d2=cmp3(q1,q2,p2);
		if(d1>=0)b.pb(p1);
		if(d1*d2<0)b.pb(interl(p1,p2,q1,q2));
	}
	return b;
}
vector<P>cut(vector<P>&a,L l){
	return cut(a,l.a,l.b);
}

vector<P>convex(vector<P>a){
	int n=a.size(),m=0; if(n<=1)return a;
	sort(a.begin(),a.end());
	vector<P>st(n*2); int tp=0;
	For(i,0,n-1){
		while(tp>1 && cmp3(st[tp-2],st[tp-1],a[i])<=0)--tp;
		st[tp++]=a[i];
	}
	int t=tp;
	Rep(i,n-2,0){
		while(tp>t && cmp3(st[tp-2],st[tp-1],a[i])<=0)--tp;
		st[tp++]=a[i];
	}
	st.resize(tp-1);
	return st;
}
db diam(vector<P>a){
	int n=a.size();
	if(n<=1)return 0;
	int ii=0,jj=0;
	For(k,1,n-1){
		if(a[k]<a[ii])ii=k;
		if(a[jj]<a[k])jj=k;
	}
	int i=ii,j=jj;
	db res=dis(a[i],a[j]);
	do{
		if((a[(i+1)%n]-a[i])*(a[(j+1)%n]-a[j])>=0) (++j)%=n;
		else (++i)%=n;
		res=max(res,dis(a[i],a[j]));
	}while(i!=ii||j!=jj);
	return res;
}

bool check(L a,L b,L c){
	return c.in(a&b);
}
int checksgn(L a,L b,L c){
	return c.in_sgn(a&b);
}
vector<L>hpis(vector<L>&l,bool is=0){
	if(!is)sort(l.begin(),l.end());
	deque<L>q;
	For(i,0,(int)l.size()-1){
		if(i&&samedir(l[i],l[i-1]))continue;
		while(q.size()>1 && !check(q[q.size()-2],q[q.size()-1],l[i]))q.pop_back();
		while(q.size()>1 && !check(q[1],q[0],l[i]))q.pop_front();
		q.pb(l[i]);
	}
	while(q.size()>2 && !check(q[q.size()-2],q[q.size()-1],q[0]))q.pop_back();
	while(q.size()>2 && !check(q[1],q[0],q[q.size()-1]))q.pop_front();
	vector<L>res;
	For(i,0,(int)q.size()-1) res.pb(q[i]);
	return res;
}

mt19937_64 rnd(64);

vector<L>cut(vector<L>&a,L l){
	vector<L>b; int n=a.size();
	For(i,0,n-1){
		L a1=a[i],a2=a[(i+1)%n],a3=a[(i+2)%n];
		int d1=checksgn(a1,a2,l),d2=checksgn(a2,a3,l);
		if(d1>0 || d2>0 || (d1==0&&d2==0)) b.pb(a2);
		if(d1>=0 && d2<0) b.pb(l);
	}
	return b;
}

L bisector(P a,P b){
	// contain a
	P o=(a+b)*0.5;
	return L(o,o+((b-a).rot90()));
}
vector<vector<L>> voronoi(vector<P>a){
	int n=a.size();
	vector<P>b=a;
	shuffle(b.begin(),b.end(),rnd);
	const db U=4e9;
	vector<vector<L>> res(n,{
		L(P(-U,-U),P(U,-U)),
		L(P(U,-U),P(U,U)),
		L(P(U,U),P(-U,U)),
		L(P(-U,U),P(-U,-U))
	});
	For(i,0,n-1){
		for(auto x:b){
			if(dis(x,a[i])>eps) {
				L tmp=bisector(a[i],x); tmp.id=x.id;
				res[i]=cut(res[i],tmp);
			}
		}
	}
	return res;
}
vector<vector<L>> neg_voronoi(vector<P>a){
	int n=a.size();
	vector<P>b=a;
	shuffle(b.begin(),b.end(),rnd);
	const db U=4e9;
	vector<vector<L>> res(n,{
		L(P(-U,-U),P(U,-U)),
		L(P(U,-U),P(U,U)),
		L(P(U,U),P(-U,U)),
		L(P(-U,U),P(-U,-U))
	});
	For(i,0,n-1){
		for(auto x:b){
			if(dis(x,a[i])>eps){
				L tmp=bisector(x,a[i]); tmp.id=x.id;
				res[i]=cut(res[i],tmp);
			}
			if(res[i].empty()) break;
		}
	}
	return res;
}

#define maxn 500005
#define inf 0x3f3f3f3f

int n;
vector<P>a;
int x[maxn],y[maxn];
db res=4e18,R;
int X,Y,Z;
bool is_l=0;

vector<L> operator &(vector<L>a,vector<L>b){
	int n=a.size()+b.size();
	vector<L>c(n);
	merge(ALL(a),ALL(b),c.begin());
	return hpis(c,1);
}

namespace Int{

struct P{
	int x,y;
	P(int x=0,int y=0):x(x),y(y){}
	P&operator +=(P o){return x+=o.x,y+=o.y,*this;}
	P&operator -=(P o){return x-=o.x,y-=o.y,*this;}
	P&operator *=(int o){return x*=o,y*=o,*this;}
	P&operator /=(int o){return x/=o,y/=o,*this;}
	friend P operator +(P a,P b){return a+=b;}
	friend P operator -(P a,P b){return a-=b;}
	friend P operator *(P a,int b){return a*=b;}
	friend P operator /(P a,int b){return a/=b;}
	friend bool operator <(P a,P b){return fabs(a.x-b.x)<eps?a.y<b.y:a.x<b.x;}
	friend bool operator ==(P a,P b){return cmp(a.x,b.x)==0 && cmp(a.y,b.y)==0;}
	friend bool operator !=(P a,P b){return !(a==b);}
	friend int operator %(P a,P b){return a.x*b.x+a.y*b.y;} // dot
	friend int operator *(P a,P b){return a.x*b.y-a.y*b.x;} // cross
	
	P rot90(){return P(-y,x);}
	db ang(){return atan2(y,x);}
	db len(){return sqrt(x*x+y*y);}
	int len2(){return x*x+y*y;}
	
	int half(){return sgn(y)==1||(sgn(y)==0&&sgn(x)>=0);}
//	P unit(){return ((*this))/len();}
	
	void read(){cin>>x>>y;}
	void out(){cout<<"("<<x<<","<<y<<")"<<endl;}
};

int cross(P a,P b,P c){
	// (a->b)*(a->c)
	return (b.x-a.x)*(c.y-a.y)-(b.y-a.y)*(c.x-a.x);
}
void interl(P p1,P p2,P q1,P q2){
	// intersect point
	int s1=cross(q1,q2,p1),s2=-cross(q1,q2,p2);
	P ps=(p1*s2+p2*s1);
	X=ps.x,Y=ps.y;
	Z=(s1+s2)*2;
}
P go(::P a){
	return P(round(a.x),round(a.y));
}
void frac_inter(L a,L b){
	a.a*=2,a.b*=2,b.a*=2,b.b*=2;
	interl(go(a.a),go(a.b),go(b.a),go(b.b));
}

}

void solve_line(){
	if(a.size()==1) {
		res=0,is_l=1;
		X=-a[0].y,Y=a[0].x,Z=0;
		return;
	}
	vector<P>b=convex(a);
	int m=b.size();
	int p=1;
	For(i,0,m-1){
		P u=b[i],v=b[(i+1)%m];
		while(cross(u,v,b[(p+1)%m])>cross(u,v,b[p])) p=(p+1)%m;
		db val=cross(u,v,b[p]);
		val/=dis(u,v),val/=2;
		if(val<res){
//			u.out(),v.out(),b[p].out();puts("---");
			res=val,is_l=1;
			P tmp=(v-u).rot90();
			X=round(v.x-u.x);
			Y=round(v.y-u.y);
			swap(X,Y),X=-X;
			Z=round((tmp%b[i])+(tmp%b[p]));
			Z/=2;
		}
	}
}
signed main()
{
	n=read(),a.resize(n);
	For(i,0,n-1) cin>>x[i]>>y[i],a[i].x=x[i],a[i].y=y[i],a[i].id=i;
	
//	if(n==100){
//		For(i,75,n-1) cout<<x[i]<<" "<<y[i]<<"\n";
//	}
	
	solve_line();
	
	auto vd=voronoi(a),nvd=neg_voronoi(a);
	For(i,0,n-1){
		sort(ALL(vd[i]));
		sort(ALL(nvd[i]));
	}
	For(i,0,n-1)if(nvd[i].size()){
		For(j,0,n-1)if(vd[j].size()){
			auto t=(nvd[i]&vd[j]);
			if(t.size()<3) continue;
		//	cout<<"siz "<<i<<" "<<j<<" "<<t.size()<<"\n";
			For(ii,0,(int)t.size()-1){
				P ps=(t[ii]&t[(ii+1)%t.size()]);
			//	if(fabs(ps.x)>=999999 || fabs(ps.y)>=999999) continue;
				db mx=dis(ps,a[i]),mn=dis(ps,a[j]);
			//	For(k,0,n-1) mn=min(mn,dis(a[k],ps)),mx=max(mx,dis(a[k],ps));
				db val=(mx-mn)*0.5;
				if(val<res){
				//	cout<<"ans "<<val<<" "<<ps.x<<" "<<ps.y<<"\n";
					res=val,is_l=0;
					R=(mn+mx)*0.5;
					Int::frac_inter(t[ii],t[(ii+1)%SZ(t)]);
				}
			}
		}
	}
	int k=__gcd(__gcd(abs(X),abs(Y)),abs(Z));
	X/=k,Y/=k,Z/=k;
	printf("%.12lf\n",(double)res);
	if(!is_l)printf("C %lld %lld %lld %.12lf\n",X,Y,Z,(double)R);
	else printf("L %lld %lld %lld\n",X,Y,Z);
	return 0;
}
/*
2
1 1
2 2
*/