#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;

using Int = long long;

template <class T1, class T2> ostream &operator<<(ostream &os, const pair<T1, T2> &a) { return os << "(" << a.first << ", " << a.second << ")"; };
template <class T> ostream &operator<<(ostream &os, const vector<T> &as) { const int sz = as.size(); os << "["; for (int i = 0; i < sz; ++i) { if (i >= 256) { os << ", ..."; break; } if (i > 0) { os << ", "; } os << as[i]; } return os << "]"; }
template <class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cerr << *i << " "; cerr << endl; }
template <class T> bool chmin(T &t, const T &f) { if (t > f) { t = f; return true; } return false; }
template <class T> bool chmax(T &t, const T &f) { if (t < f) { t = f; return true; } return false; }


int sig(Int r) { return (r < 0) ? -1 : (r > 0) ? +1 : 0; }
struct Pt {
  Int x, y;
  Pt() : x(0), y(0) {}
  Pt(Int x_, Int y_) : x(x_), y(y_) {}
  Pt operator+(const Pt &a) const { return Pt(x + a.x, y + a.y); }
  Pt operator-(const Pt &a) const { return Pt(x - a.x, y - a.y); }
  Pt operator*(const Pt &a) const { return Pt(x * a.x - y * a.y, x * a.y + y * a.x); }
  Pt operator+() const { return Pt(+x, +y); }
  Pt operator-() const { return Pt(-x, -y); }
  Pt operator*(const Int &k) const { return Pt(x * k, y * k); }
  Pt operator/(const Int &k) const { return Pt(x / k, y / k); }
  friend Pt operator*(const Int &k, const Pt &a) { return Pt(k * a.x, k * a.y); }
  Pt &operator+=(const Pt &a) { x += a.x; y += a.y; return *this; }
  Pt &operator-=(const Pt &a) { x -= a.x; y -= a.y; return *this; }
  Pt &operator*=(const Pt &a) { return *this = *this * a; }
  Pt &operator*=(const Int &k) { x *= k; y *= k; return *this; }
  Int abs2() const { return x * x + y * y; }
  Int dot(const Pt &a) const { return x * a.x + y * a.y; }
  Int det(const Pt &a) const { return x * a.y - y * a.x; }
  bool operator==(const Pt &a) const { return (x == a.x && y == a.y); }
  bool operator<(const Pt &a) const { return (x < a.x || (x == a.x && y < a.y)); }
  friend ostream &operator<<(ostream &os, const Pt &a) { os << "(" << a.x << ", " << a.y << ")"; return os; }
};
Int tri(const Pt &a, const Pt &b, const Pt &c) { return (b - a).det(c - a); }

// (-(1/2)PI, (3/2)PI]
int cmpArg(const Pt &a, const Pt &b) {
  const int sa = (a.x > 0) ? 0 : (a.x < 0) ? 2 : (a.y > 0) ? 1 : 3;
  const int sb = (b.x > 0) ? 0 : (b.x < 0) ? 2 : (b.y > 0) ? 1 : 3;
  return (sa < sb) ? -1 : (sa > sb) ? +1 : sig(b.det(a));
}


unsigned xrand() {
  static unsigned x = 314159265, y = 358979323, z = 846264338, w = 327950288;
  unsigned t = x ^ x << 11; x = y; y = z; z = w; return w = w ^ w >> 19 ^ t ^ t >> 8;
}


using Double = double;
constexpr Double INF = 1e+20;

int N;
vector<Pt> P;

Double D[310][310];
char S[310][310][310];

// inside triangle 0, i, j
int cnt[310][310];

// inside triangle i, j, k
int enclose(int i, int j, int k) {
  int ret = 0;
  ret += cnt[i][j];
  ret += cnt[j][k];
  ret += cnt[k][i];
  ret -= (S[0][j][i] + S[j][k][i] + S[k][0][i]) / 3;
  ret -= (S[0][k][j] + S[k][i][j] + S[i][0][j]) / 3;
  ret -= (S[0][i][k] + S[i][j][k] + S[j][0][k]) / 3;
#ifdef LOCAL
int brt=0;
for(int l=0;l<N;++l)brt+=abs((S[i][j][l]+S[j][k][l]+S[k][i][l])/3);
if(brt!=ret)cerr<<P[i]<<" "<<P[j]<<" "<<P[k]<<": "<<brt<<" "<<ret<<endl;
assert(brt==ret);
#endif
  return ret;
}

Double cost[310][310];

using Dir = pair<Pt, pair<int, pair<int, int>>>;
vector<Dir> dirs;

// s: min (x, y)
// area - ratio * length >= 0
bool check(int src, Double ratio) {
  vector<Double> dp(N, -INF);
  Double start = 0.0, goal = -INF;
  for (const auto &dir : dirs) {
    const int i = dir.second.second.first;
    const int j = dir.second.second.second;
    if (dir.second.first == 0) {
      if (S[src][i][j] >= 0 && enclose(src, i, j) == 0) {
// cerr<<i<<" -> "<<j<<endl;
        chmax((src == j) ? goal : dp[j], ((src == i) ? start : dp[i]) + tri(P[src], P[i], P[j]) / 2.0 - ratio * cost[i][j]);
      }
    } else {
// cerr<<"impose "<<i<<" "<<D[i][j]<<endl;
      if (src == i) {
        if (dir.first.x > 0 || (dir.first.x == 0 && dir.first.y > 0)) {
          // impose when: arg(dir) < go
          start -= ratio * D[i][j];
        } else {
          // impose when: come <= arg(dir)
          goal -= ratio * D[i][j];
        }
      } else {
        dp[i] -= ratio * D[i][j];
      }
    }
  }
// cerr<<src<<" "<<ratio<<" "<<dp<<" "<<goal<<endl;
  return (goal >= 0.0);
}

int main() {
  for (int numCases; ~scanf("%d", &numCases); ) { for (int caseId = 1; caseId <= numCases; ++caseId) {
    scanf("%d", &N);
    P.resize(N);
    for (int i = 0; i < N; ++i) {
      scanf("%lld%lld", &P[i].x, &P[i].y);
    }
    sort(P.begin(), P.end());
    
    for (int i = 0; i < N; ++i) for (int j = 0; j < N; ++j) {
      D[i][j] = sqrt((Double)(P[j] - P[i]).abs2());
    }
    for (int i = 0; i < N; ++i) for (int j = 0; j < N; ++j) for (int k = 0; k < N; ++k) {
      S[i][j][k] = sig(tri(P[i], P[j], P[k]));
    }
    
    for (int i = 0; i < N; ++i) {
      fill(cnt[i], cnt[i] + N, 0);
    }
    for (int i = 0; i < N; ++i) for (int j = 0; j < N; ++j) if (S[0][i][j] > 0) {
      for (int k = 0; k < N; ++k) {
        cnt[i][j] += (S[0][i][k] + S[i][j][k] + S[j][0][k]) / 3;
      }
      cnt[j][i] = -cnt[i][j];
    }
// if(N<=3)for(int i=0;i<N;++i)for(int j=0;j<N;++j)for(int k=0;k<N;++k)cerr<<i<<" "<<j<<" "<<k<<": "<<enclose(i,j,k)<<endl;
    
    /*
      cost of j at corner i:
        - come in [arg(P[j] - P[i]) - PI/2, arg(P[j] - P[i]) + PI/2]
        - go   in [arg(P[j] - P[i]) + PI/2, arg(P[j] - P[i]) - PI/2]
      
      for src != i
      impose when: come <= arg(P[j] - P[i]) + PI/2 < go
      (ignore non-convex turning)
      
      remaining cost: projected on the segment [i, j)
    */
    // projected on the segment
    for (int i = 0; i < N; ++i) for (int j = 0; j < N; ++j) {
      cost[i][j] = D[i][j];
      for (int k = 0; k < N; ++k) {
        if (S[i][j][k] < 0 &&
            (P[j] - P[i]).dot(P[k] - P[i]) >= 0 &&
            (P[i] - P[j]).dot(P[k] - P[j]) >  0) {
          cost[i][j] += min(D[i][k], D[j][k]);
        }
      }
    }
    
    dirs.clear();
    for (int i = 0; i < N; ++i) for (int j = 0; j < N; ++j) if (i != j) {
      dirs.emplace_back(P[j] - P[i], make_pair(0, make_pair(i, j)));
      dirs.emplace_back((P[j] - P[i]) * Pt(0, 1), make_pair(1, make_pair(i, j)));
    }
    sort(dirs.begin(), dirs.end(), [&](const Dir &dir0, const Dir &dir1) -> bool {
      const int s = cmpArg(dir0.first, dir1.first);
      return (s ? (s < 0) : (dir0.second < dir1.second));
    });
// cerr<<"dirs = "<<dirs<<endl;
// cerr<<"P = "<<P<<endl;check(1,0.71);continue;
    
    vector<int> srcs(N);
    for (int i = 0; i < N; ++i) {
      swap(srcs[xrand() % (i + 1)], srcs[i] = i);
    }
    Double lo = 0.0;
    for (const int src : srcs) {
      if (check(src, lo)) {
        Double hi = 1e+9;
        for (int iter = 0; iter < 60; ++iter) {
          const Double mid = (lo + hi) / 2.0;
          (check(src, mid) ? lo : hi) = mid;
        }
      }
    }
    printf("%.12f\n", lo);
  }
#ifndef LOCAL
  break;
#endif
  }
  return 0;
}