#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
typedef double ld;

mt19937 rnd(239);

const ld eps = 1e-12;
const ld INF = 1e18;

struct vect {
    int x, y;

    vect() = default;

    vect(int x_, int y_) : x(x_), y(y_) {
    }

    vect operator-(const vect& other) const {
        return vect(x - other.x, y - other.y);
    }

    bool operator<(const vect& other) const {
        return make_pair(y, x) < make_pair(other.y, other.x);
    }

    ll operator*(const vect& other) const {
        return (ll)x * (ll)other.x + (ll)y * (ll)other.y;
    }

    ll operator^(const vect& other) const {
        return (ll)x * (ll)other.y - (ll)y * (ll)other.x;
    }

    ld len() const {
        return hypotl(x, y);
    }

    int half() const {
        return (y < 0 || (y == 0 && x < 0));
    }

    vect rot() const {
        return vect(-y, x);
    }

    void read() {
        cin >> x >> y;
    }
};

int cmp_angle(const vect& v1, const vect& v2) {
    if (v1.half() != v2.half()) {
        return v1.half() < v2.half() ? 1 : -1;
    }
    ll prod = (v1 ^ v2);
    if (prod != 0) {
        return prod > 0 ? 1 : -1;
    }
    return 0;
}

const int M = 310;
const int ITERATIONS = 60;

int n;
vect a[M];
ld len[M][M], dist[M][M], dist2[M][M];
ll area[M][M];

struct Pair {
    int s, f, type;

    vect vec() const {
        if (type == 0) {
            return a[f] - a[s];
        }
        return (a[f] - a[s]).rot();
    }
};

bool cmp_pairs(const Pair& p1, const Pair& p2) {
    vect v1 = p1.vec();
    vect v2 = p2.vec();
    int c = cmp_angle(v1, v2);
    if (c != 0) {
        return c > 0;
    }
    if (p1.type == p2.type) {
        return make_pair(p1.s, p1.f) < make_pair(p2.s, p2.f);
    }
    return p1.type < p2.type;
}

int used_indices[M * M * 2], cnt_used;
ld dp[M];
int used[M * M * 2], l_used;
vector<Pair> pairs;
int s, f;

bool check(int start, ld x) {
    x *= 2;
    for (int i = 0; i < n; i++) {
        for (int j = max(start, i + 1); j < n; j++) {
            dist2[i][j] = dist[i][j] * x;
        }
        dp[i] = -INF - 100;
    }
    dp[start] = -eps;
    for (int idx = 0; idx < cnt_used; idx++) {
        s = pairs[used_indices[idx]].s;
        f = pairs[used_indices[idx]].f;
        if (pairs[used_indices[idx]].type == 0) {
            dp[f] = max(dp[f], dp[s] + area[s][f] - len[s][f] * x);
        } else {
            dp[s] -= dist2[min(s, f)][max(s, f)];
        }
    }
    return dp[start] >= 0.0;
}

vector<int> pts;
int idx[M], mn[M];

void solve() {
    cin >> n;
    for (int i = 0; i < n; i++) {
        a[i].read();
    }
    sort(a, a + n);

    pairs.clear();
    pairs.reserve(2 * n * n);
    for (int i = 0; i < n; i++)
        for (int j = 0; j <= i; j++)
            dist[i][j] = dist[j][i] = (a[i] - a[j]).len();
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if (i != j) {
                pairs.emplace_back(Pair{i, j, 0});
                pairs.emplace_back(Pair{i, j, 1});
                len[i][j] = dist[i][j];
                for (int h = 0; h < n; h++) {
                    if (h != i && h != j) {
                        if (((a[j] - a[i]) * (a[h] - a[i])) < 0) {
                            continue;
                        }
                        if (((a[i] - a[j]) * (a[h] - a[j])) <= 0) {
                            continue;
                        }
                        if (((a[h] - a[i]) ^ (a[j] - a[i])) <= 0) {
                            continue;
                        }
                        len[i][j] += min(dist[h][i], dist[h][j]);
                    }
                }
            }
        }
    }
    sort(pairs.begin(), pairs.end(), cmp_pairs);

    vector<int> order(n);
    iota(order.begin(), order.end(), 0);
    shuffle(order.begin(), order.end(), rnd);

    ld ans = 0.0;

    for (int start : order) {
        pts.clear();
        for (int i = start; i < n; i++) {
            pts.emplace_back(i);
            mn[i] = n;
        }
        sort(pts.begin(), pts.end(), [&](int i, int j) {
            if (i == j) {
                return false;
            }
            int x = cmp_angle(a[i] - a[start], a[j] - a[start]);
            if (x == 0) {
                return (i == start) > (j == start);
            }
            return x > 0;
        });
        for (int i = 0; i < (int)pts.size(); i++) {
            idx[pts[i]] = i;
        }
        l_used++;
        for (int id = (int)pairs.size() - 1; id >= 0; id--) {
            s = pairs[id].s;
            f = pairs[id].f;
            if (s < start) {
                continue;
            }
            if (pairs[id].type == 0) {
                if (f < start) {
                    continue;
                }
                if (s == start || f == start) {
                    used[id] = l_used;
                    area[s][f] = 0;
                    continue;
                }
                if (idx[s] > idx[f] || mn[s] < idx[f]) {
                    continue;
                }
                mn[s] = idx[f];
                used[id] = l_used;
                area[s][f] = abs((a[s] - a[start]) ^ (a[f] - a[start]));
            } else {
                used[id] = l_used;
            }
        }
        cnt_used = 0;
        for (int i = 0; i < (int)pairs.size(); i++) {
            if (used[i] == l_used) {
                used_indices[cnt_used++] = i;
            }
        }

        if (!check(start, ans + eps)) {
            continue;
        }

        if (ans < 1.0 && check(start, 1.0)) {
            ans = 1.0;
        }
        ld l = ans;
        ld r = (ans < 1.0 - eps ? 1.0 : 1e6);
        for (int it = 0; it < ITERATIONS; it++) {
            ld mid = (l + r) / 2;
            if (l >= 1.0 - eps) {
                mid = sqrt(l * r);
            }
            if (check(start, mid)) {
                l = mid;
            } else {
                r = mid;
            }
        }
        ans = l;
    }

    cout << ans << "\n";
}

int main() {
#ifdef ONPC
    freopen("input", "r", stdin);
#endif
    ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
    cout << fixed << setprecision(10);

    int t;
    cin >> t;
    while (t--) {
        solve();
    }

    return 0;
}