#pragma GCC optimize("Ofast")
#include<bits/stdc++.h>

#define db double
#define vc vector
#define pb emplace_back
#define ll long long
#define rep(i, a, b) for(int i = (a); i <= (b); ++i)
#define lep(i, a, b) for(int i = (a); i >= (b); --i)

using namespace std;

inline int read() {
	int x = 0, w = 0; char ch = getchar(); while(!isdigit(ch)) w |= (ch == '-'), ch = getchar();
	while(isdigit(ch)) x = x * 10 + (ch ^ 48), ch = getchar(); return w ? -x : x; 
}

const int N = 305;
const db inf = 1e18, eps = 1e-7;

namespace Geometry {
	struct vec { 
		int x, y; 
		vec rotate() { return vec{-y, x}; }
		inline bool section() { return y ? y > 0 : x > 0; }
		friend ll crs(vec a, vec b) { return 1ll * a.x * b.y - 1ll * a.y * b.x; }
		friend ll dot(vec a, vec b) { return 1ll * a.x * b.x + 1ll * a.y * b.y; }
		friend db dis(vec a, vec b) { return sqrt(1ll * (a.x - b.x) * (a.x - b.x) + 1ll * (a.y - b.y) * (a.y - b.y)); }
		friend db S(vec a, vec b) { return (db)crs(a, b) / 2.0; }
		friend bool operator < (vec a, vec b) { return a.section() == b.section() ? crs(a, b) > 0 : a.section(); }
		friend bool operator <= (vec a, vec b) { return !(b < a);}
		friend vec operator - (vec a, vec b) { return vec{a.x - b.x, a.y - b.y}; }
	} a[N];
	
	struct edge { 
		int u, v; vec w; 
		friend bool operator < (edge a, edge b) { return a.w < b.w; }
	} e[N * N];
}
using namespace Geometry;

int n, m, id[N], ok[N][N];
db dp[N], d[N][N], f[N][N];

inline void prework(int st) {
	vc<int> mn(n + 1, n + 1), rk(n + 1, 0), o;
	rep(i, st + 1, n) o.pb(i);
	sort(o.begin(), o.end(), [&](int a, int b) {
		return ::a[a] - ::a[st] < ::a[b] - ::a[st];
	});
	rep(i, 0, n - st - 1) rk[o[i]] = i;
	lep(i, m, 1) {
		int u = e[i].u, v = e[i].v;
		if(u > st && v > st && rk[v] > rk[u] && rk[v] < mn[u]) 
			mn[u] = rk[v], ok[u][v] = st;
	}
}

inline bool check(int st, db lam) {
	rep(i, st, n) dp[i] = -inf;
	rep(i, 1, m) {
		int u = e[i].u, v = e[i].v;
		if(u < st || v < st) continue;
		if(u == st) dp[v] = max(dp[v], - f[u][v] * lam);
		else if(v == st) dp[v] = max(dp[v], dp[u] - f[u][v] * lam);
		else if(ok[u][v] == st) 
			dp[v] = max(dp[v], dp[u] - f[u][v] * lam + S(a[u] - a[st], a[v] - a[st]));
	}
	rep(i, 1, n) dp[st] -= d[st][i] * lam;
	return dp[st] >= 0;
}

inline void solve() {	
	n = read(); m = 0; 
	rep(i, 1, n) id[i] = i, a[i].x = read(), a[i].y = read();
	
	sort(a + 1, a + 1 + n, [&](vec a, vec b) {
		return a.y == b.y ? a.x < b.x : a.y < b.y;
	});
	
	rep(i, 1, n) rep(j, i, n) d[i][j] = d[j][i] = dis(a[i], a[j]);
	
	rep(i, 1, n) rep(j, 1, n) if(i != j) {
		e[++m] = edge{i, j, a[j] - a[i]}; 
		f[i][j] = d[i][j]; ok[i][j] = 0;
		rep(k, 1, n) {
			if(crs(a[k] - a[i], a[j] - a[i]) > 0) 
				if(dot(a[k] - a[i], a[j] - a[i]) >= 0 && dot(a[k] - a[j], a[i] - a[j]) >= 0)
					f[i][j] += min(d[i][k], d[j][k]);
			if((a[j] - a[i]) <= (a[k] - a[i]).rotate()) f[i][j] -= d[i][k];
			if((a[j] - a[i]) < (a[k] - a[j]).rotate()) f[i][j] += d[j][k];
		}
	}
	
	sort(e + 1, e + 1 + m);
	random_shuffle(id + 1, id + 1 + n);
	
	db l = 0, r, mid ;
	for(int t = 1, x; t <= n; t++) {
		prework(x = id[t]);
		if(!check(x, l)) continue;
		r = 1e6;
		while(l + eps < r) 
			if(check(x, mid = (l + r) / 2)) l = mid;
			else r = mid;
	}
	
	printf("%.10lf\n", l);
}

signed main() {
	int t = read(); while(t--) solve();
	return 0;
}