#include <bits/stdc++.h>
using namespace std;
const int N = 3e2 + 5;
typedef long long i64;
typedef double db;
typedef pair<int,int> pii;
#define FI first
#define SE second
const db eps = 1e-9,PI = acos(-1.0);
mt19937 Rnd(114514);
struct Vec {
	int x,y;
	Vec(){}
	Vec(const int _x,const int _y):x(_x),y(_y){}
	Vec operator + (const Vec &rhs) const { return Vec(x + rhs.x,y + rhs.y);}
	Vec operator - (const Vec &rhs) const { return Vec(x - rhs.x,y - rhs.y);}
	i64 operator * (const Vec &rhs) const { return 1ll * x * rhs.y - 1ll * y * rhs.x;}
};
Vec O(0,0);
bool Cmp(const Vec &x,const Vec &y) { return (x.y == y.y) ? (x.x < y.x) : (x.y < y.y);}
i64 Dot(const Vec &A,const Vec &B) { return 1ll * A.x * B.x + 1ll * A.y * B.y;}
db Distance(const Vec &A,const Vec &B) { return sqrt(Dot(A - B,A - B));}
db Angle(const Vec &A) { 
	db tmp = atan2(A.y,A.x);
	// if(tmp < -eps) return tmp + PI * 2;
	// else 
	return tmp;
}
db Area(const Vec &A,const Vec &B,const Vec &C) { return 0.5 * fabs(A * B + B * C + C * A);}
bool Equal(const db &A,const db &B) { return fabs(A - B) < eps;}
db Angle(const Vec &A,const Vec &B,const Vec &C) { // jiao ABC
	return Angle(A - B) - Angle(C - B);
}
bool InSegment(const Vec &A,const Vec &B,const Vec &p) { return Equal(Distance(A,p) + Distance(p,B),Distance(A,B));}
bool InTriangle(const Vec &A,const Vec &B,const Vec &C,const Vec &p) {
	return Equal(Area(A,B,p) + Area(B,C,p) + Area(C,A,p),Area(A,B,C));
}
Vec Rotate(const Vec &A) { return Vec(-A.y,A.x);}
int sgn(const Vec &A) { return A.y > 0 || A.y == 0 && A.x > 0;}
Vec p[N];
int n;
int V[N][N],VL[N][N]; 
db sum[N][N];
bool NeedAdd(const Vec &A,const Vec &B,const Vec &p) {
	if(!InTriangle(O,A,B,p)) return 0;
	if(InSegment(O,A,p)) return 0;
	return 1;
}
inline bool CheckTriangle(int i,int j,int k) {
	
	if(InSegment(p[i],p[j],p[k])) return VL[i][j] <= 1;
	if(InSegment(p[i],p[k],p[j])) return VL[i][k] <= 1;
	if(InSegment(p[j],p[k],p[i])) return VL[j][k] <= 1;
	if(VL[i][j] || VL[j][k] || VL[i][k]) return false;
	// if(i == 1 && j == 1 && k == 4) puts("done");
	int num = 0;
	int v1 = V[i][j] - NeedAdd(p[i],p[j],p[k]);
	int v2 = V[j][k] - NeedAdd(p[j],p[k],p[i]);
	int v3 = V[k][i] - NeedAdd(p[k],p[i],p[j]);
	if(p[i] * p[j] > 0) num += v1; else if(p[i] * p[j] < 0) num -= v1;
	if(p[j] * p[k] > 0) num += v2; else if(p[j] * p[k] < 0) num -= v2;
	if(p[k] * p[i] > 0) num += v3; else if(p[k] * p[i] < 0) num -= v3;
	// int brt = 0;
	// for(int t = 1;t <= n;t++)
	// 	if(i != t && j != t && k != t && InTriangle(p[i],p[j],p[k],p[t])) ++brt;
	// if(abs(num) != brt) {
	// 	printf("%d %d %d\n",i,j,k);
	// 	printf("p[%d]:%d,%d\n",i,p[i].x,p[i].y);
	// 	printf("p[%d]:%d,%d\n",j,p[j].x,p[j].y);
	// 	printf("p[%d]:%d,%d\n",k,p[k].x,p[k].y);
	// 	printf("%d %d %d\n",v1,v2,v3);
	// 	exit(0);
	// }
	// // assert(num % 2 == 0);
	// assert(abs(num) == brt);
	return num == 0;
}

struct Line {
	int s,t,type;
	Vec v;
	Line(){}
	Line(const int _s,const int _t,const int _type,const Vec _v):
		s(_s),t(_t),type(_type),v(_v){}
	bool operator < (const Line &rhs) const { 
		// return Angle(v) < Angle(rhs.v);
		int t1 = sgn(this->v),t2 = sgn(rhs.v);
		if(t1 != t2) return t1 > t2;
		i64 val = this->v * rhs.v;
		// db val = Angle(this->v) - Angle(rhs.v);
		if(val) return val > 0;
		else return type < rhs.type;
	}
};
Line L[N * N];
int tot;
inline void Init() {
	cin >> n;
	for(int i = 1;i <= n;i++) cin >> p[i].x >> p[i].y;
	sort(p + 1,p + n + 1,Cmp);
	for(int i = 1;i <= n;i++) 
		for(int j = 1;j <= n;j++)
			for(int k = 1;k <= n;k++) {
				if(k == i || k == j) continue;	
				if(!InTriangle(p[i],O,p[j],p[k])) continue;

				// if(InSegment(O,p[i],p[k]) || (!InSegment(O,p[j],p[k]) && !InSegment(O,p[i],p[k])))
				// // if(InSegment(p[i],p[j],p[k]) || (!InSegment(O,p[i],p[k]) && !InSegment(O,p[j],p[k])))
				if(NeedAdd(p[i],p[j],p[k]))
					++V[i][j];
				if(InSegment(p[i],p[j],p[k])) ++VL[i][j];
			}
	// printf("V,VL[1,2]:%d,%d\n",V[1][2],VL[1][2]);
	// printf("V,VL[3,1]:%d,%d\n",V[3][1],VL[3][1]);
	// printf("V,VL[2,3]:%d,%d\n",V[2][3],VL[2][3]);
	for(int i = 1;i <= n;i++)
		for(int j = 1;j <= n;j++)
			for(int k = 1;k <= n;k++) {
				if(k == i || k == j) continue;
				if((p[k] - p[i]) * (p[j] - p[i]) <= 0) continue;
				if(Dot(p[j] - p[i],p[k] - p[i]) >= 0 && Dot(p[i] - p[j],p[k] - p[j]) > 0)
					sum[i][j] += min(Distance(p[k],p[i]),Distance(p[k],p[j]));
			}
	for(int i = 1;i <= n;i++)
		for(int j = 1;j <= n;j++) {
			if(i == j) continue;
			sum[i][j] += Distance(p[i],p[j]);
			L[++tot] = Line(i,j,0,p[j] - p[i]);
			L[++tot] = Line(i,j,1,Rotate(p[j] - p[i]));
		}
	// printf("Angle(1,2):%.6lf\n",Angle(p[2] - p[1]));
	// printf("Angle(1,3):%.6lf\n",Angle(p[3] - p[1]));
	// printf("Angle(2,1):%.6lf\n",Angle(p[1] - p[2]));
	// printf("Angle(2,3):%.6lf\n",Angle(p[3] - p[2]));
	// printf("Angle(3,1):%.6lf\n",Angle(p[1] - p[3]));
	// printf("Angle(3,2):%.6lf\n",Angle(p[2] - p[3]));

	sort(L + 1,L + tot + 1);
}

db dp[N];
inline bool Check(int st,db mid) {
	for(int i = 1;i <= n;i++) dp[i] = -1e15;
	dp[st] = -eps;
	// printf("Check:%d\n",st);
	for(int i = 1;i <= tot;i++) {
		int s = L[i].s,t = L[i].t,tp = L[i].type;
		// printf("L:%d,%d,%d\n",s,t,tp);
		// printf("CheckTriangle[%d,%d,%d]:%d\n",st,s,t,CheckTriangle(st,s,t));
		if(tp == 1) {
			if(s >= st) dp[s] -= mid * Distance(p[s],p[t]);
		} else 
			if(s >= st && t >= st && CheckTriangle(st,s,t))
				dp[t] = max(dp[t],dp[s] + Area(p[st],p[s],p[t]) - mid * sum[s][t]); 
	}
	// for(int i = 1;i <= n;i++) printf("dp[%d]=%.12lf\n",i,dp[i]);
	return dp[st] > eps;
}
inline void Clr(int n) {
	for(int i = 1;i <= n;i++) for(int j = 1;j <= n;j++) V[i][j] = VL[i][j] = sum[i][j] = 0;
	tot = 0;
}
inline void work() {
	Clr(n);
	Init();
	static int perm[N];
	for(int i = 1;i <= n;i++) perm[i] = i;
	shuffle(perm + 1,perm + n + 1,Rnd);
	db ans = 0;
	// printf("Check:%d\n",Check(1,0));
	for(int i = 1;i <= n;i++) 
		if(Check(perm[i],ans)) {
			db lef = ans,rig = 1e6;
			for(int _ = 1;_ <= 60;_++) {
				db mid = (lef + rig) / 2;
				if(Check(perm[i],mid)) lef = mid;
				else rig = mid;
			}
			ans = lef;
		}
	printf("%.10lf\n",ans);
}
int main() {
	int T;
	cin >> T;
	while(T--) work();
	return 0;
}
/*
1
4
0 -5
5 -5
0 -2
-3 2
*/