#include <bits/stdc++.h>

using i64 = long long;

std::mt19937 rng(std::chrono::steady_clock::now().time_since_epoch().count());

struct Point {
    int x = 0;
    int y = 0;
};

Point operator-(const Point &a, const Point &b) {
    return {a.x - b.x, a.y - b.y};
}

int cross(const Point &a, const Point &b) {
    return a.x * b.y - a.y * b.x;
}

int dot(const Point &a, const Point &b) {
    return a.x * b.x + a.y * b.y;
}

using real = long double;

int sgn(const Point &a) {
    if (a.y > 0 || (a.y == 0 && a.x > 0)) {
        return 1;
    }
    return -1;
}

void chmax(real &a, real b) {
    if (a < b) {
        a = b;
    }
}

void solve() {
    int n;
    std::cin >> n;
    
    std::vector<Point> a(n);
    for (int i = 0; i < n; i++) {
        std::cin >> a[i].x >> a[i].y;
    }
    
    std::vector<int> perm(n);
    std::iota(perm.begin(), perm.end(), 0);
    std::shuffle(perm.begin(), perm.end(), rng);
    real ans = 0;
    
    std::vector<std::vector<int>> p(n);
    for (int i = 0; i < n; i++) {
        p[i].reserve(n);
        for (int j = 0; j < n; j++) {
            if (i != j) {
                p[i].push_back(j);
            }
        }
        std::sort(p[i].begin(), p[i].end(),
            [&](int u, int v) {
                int su = sgn(a[u] - a[i]);
                int sv = sgn(a[v] - a[i]);
                if (su != sv) {
                    return su == 1;
                }
                return cross(a[u] - a[i], a[v] - a[i]) > 0;
            });
    }
    
    std::vector dp(n, std::vector<real>(n));
    auto check = [&](int s, real x) {
        int m = 0;
        while (m < n - 1 && sgn(a[p[s][m]] - a[s]) == 1) {
            m++;
        }
        std::vector<int> id(n, -1);
        for (int i = 0; i < m; i++) {
            id[p[s][i]] = i;
        }
        id[s] = m;
        dp.assign(n, std::vector(n, real(-INFINITY)));
        for (int i = 0; i < m; i++) {
            int t = p[s][i];
            dp[s][t] = cross(a[s], a[t]) - x * dot(a[s] - a[t], a[s] - a[t]);
            // for (int v = 0; v < n; v++) {
            //     for (int u = 0; u < n; u++) {
            //         if (id[v] > i && cross(a[t] - a[u], a[v] - a[t]) > 0) {
            //             chmax(dp[t][v], dp[u][t] + cross(a[t], a[v]) - x * dot(a[t] - a[v], a[t] - a[v]));
            //         }
            //     }
            // }
            int l = std::find(p[t].begin(), p[t].end(), s) - p[t].begin() + 1;
            real mx = dp[s][t];
            for (int j = l, k = l; j < l + n - 1; j++) {
                int v = p[t][j % (n - 1)];
                if (id[v] > i) {
                    while (k < l + n - 1 && cross(a[t] - a[p[t][k % (n - 1)]], a[v] - a[t]) > 0) {
                        chmax(mx, dp[p[t][k % (n - 1)]][t]);
                        k++;
                    }
                    chmax(dp[t][v], mx + cross(a[t], a[v]) - x * dot(a[t] - a[v], a[t] - a[v]));
                }
            }
            if (dp[t][s] >= 0) {
                return true;
            }
        }
        return false;
    };
    
    for (auto i : perm) {
        if (!check(i, ans)) {
            continue;
        }
        real lo = ans, hi = 1E9;
        while (hi - lo > std::max<real>(lo, 1) * 1E-10) {
            real x = (lo + hi) / 2;
            if (check(i, x)) {
                lo = x;
            } else {
                hi = x;
            }
        }
        ans = lo;
    }
    std::cout << ans / 2 << "\n";
}

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    
    std::cout << std::fixed << std::setprecision(10);
    
    int t;
    std::cin >> t;
    
    while (t--) {
        solve();
    }
    
    return 0;
}