/* name: 6436
 * author: 5ab
 * created at: 2023-06-04
 */
#include <iostream>
#include <algorithm>
#include <iomanip>
#include <vector>
#include <cmath>
using namespace std;

typedef long long ll;
using db = double;

const int max_n = 500000;

struct point
{
	int x, y;
	point operator-(const point& rhs) const {
		return point{ x - rhs.x, y - rhs.y };
	}
	bool operator==(const point& rhs) const = default;
}
a[max_n], b[max_n + 1], O = {0, 0};

inline void chmax(db& _a, db _b) { if (_a < _b) _a = _b; }
inline bool cclkw(point x, point y)
{
	return 1ll * x.x * y.y > 1ll * x.y * y.x;
}
inline bool cln(point x, point y)
{
	return 1ll * x.x * y.y == 1ll * x.y * y.x;
}
inline db cross(point x, point y)
{
	return 1ll * x.x * y.y - 1ll * x.y * y.x;
}
inline bool smd(point x, point y)
{
	return cln(x, y) && 1ll * x.x * y.x + 1ll * x.y * y.y > 0;
}
inline db dis(point x, point y)
{
	return hypot(x.x - y.x, x.y - y.y);
}

template<class It>
void cr(It bg, It ed)
{
	swap(*bg, *min_element(bg, ed, [](auto& x, auto& y) {
		return x.x == y.x ? x.y < y.y : x.x < y.x;
	}));
	sort(bg + 1, ed, [&](auto& lhs, auto& rhs) {
		ll v = cross(lhs - *bg, rhs - *bg);
		return v ? v > 0 : smd(lhs - *bg, rhs - lhs);
	});
}

template<class It>
db calc(It bg, It ed)
{
	db res = dis(*bg, *prev(ed));
	for (auto s = bg, t = next(bg); t != ed; s++, t++)
		res += dis(*s, *t);
	return res;
}

db solve1(int n)
{
	b[0] = {0, 0};
	copy(a, a + n, b + 1);
	cr(b, b + n + 1);
	
	static vector<point> c1, c2;
	c1.clear(), c2.clear();
	
	for (int i = 0; i <= n; i++)
	{
		while (ssize(c1) > 1 && cclkw(b[i] - c1.back(), c1.back() - end(c1)[-2]))
			c2.push_back(c1.back()), c1.pop_back();
		c1.push_back(b[i]);
	}
	// for (auto [x, y] : c1)
	// 	cerr << "(" << x << "," << y << ") ";
	// cerr << endl;
	// for (auto [x, y] : c2)
	// 	cerr << "(" << x << "," << y << ") ";
	// cerr << endl;
	
	// check colinearity
	for (int i = 1; i < ssize(c1) - 1; i++)
		if (cln(c1[i + 1] - c1[i], c1[i] - c1[i - 1]))
			return 0;
	for (int i = 1; i <= n; i++)
	{
		if (c1.back() != b[i] && cln(c1.back() - b[i], b[i] - b[0]))
			return 0;
		if (c1[1] != b[i] && cln(c1[1] - b[i], b[i] - b[0]))
			return 0;
	}
	if (find(c1.begin(), c1.end(), O) == c1.end())
		return 0;
	
	c2.push_back(O);
	cr(c2.begin(), c2.end());
	for (int i = 0; i < ssize(c2); i++)
		if (!cclkw(c2[i] - c2[(i - 1 + ssize(c2)) % ssize(c2)], c2[(i + 1) % ssize(c2)] - c2[i]))
			return 0;
	
	return calc(c1.begin(), c1.end()) + calc(c2.begin(), c2.end());
}

db solve2(int n)
{
	int l = partition(a, a + n, [](auto& x) {
		return x.y < 0 || (x.y == 0 && x.x > 0);
	}) - a;
	sort(a, a + l, cclkw), sort(a + l, a + n, cclkw);
	
	auto nxt = [&](int x) {
		return x + 1 == n ? 0 : x + 1;
	};
	for (int i = 0; i < n; i++)
		if (smd(a[i], a[nxt(i)]))
			return 0;
	
	db ans = 0, bsv = calc(a, a + n);
	vector<int> xps;
	
	auto pre = [&](int x) {
		return x == 0 ? n - 1 : x - 1;
	};
	for (int i = 0; i < n; i++)
		if (!cclkw(a[i] - a[pre(i)], a[nxt(i)] - a[i]))
			xps.push_back(i);
	if (xps.size() > 4)
		return 0;
	
	auto od = [&](int id) {
		return hypot(a[id].x, a[id].y);
	};
	for (int i = 0, j = 1; i < n; i++)
	{
		while (nxt(j) != i && !cclkw(O - a[i], a[nxt(j)]))
		{
			// cerr << i << " " << j << " " << a[i].x << " " << a[i].y << " " << a[nxt(j)].x << " " << a[nxt(j)].y << endl;
			j = nxt(j);
		}
		if (!cclkw(O - a[i], a[nxt(j)]) || !cclkw(O - a[j], a[nxt(i)]))
			continue;
		bool ok = true;
		for (int x : xps)
			if (x != i && x != j && x != nxt(i) && x != nxt(j))
			{
				ok = false;
				break;
			}
		if (ok)
		{
			// cerr << i << " " << j << endl;
			chmax(ans, bsv - dis(a[i], a[nxt(i)]) - dis(a[j], a[nxt(j)])
			               + od(i) + od(nxt(i)) + od(j) + od(nxt(j)));
		}
	}
	return ans;
}

signed main()
{
	ios_base::sync_with_stdio(false);
	cin.tie(nullptr);
	
	int cas, n;
	
	cin >> cas;
	while (cas--)
	{
		cin >> n;
		for (int i = 0; i < n; i++)
			cin >> a[i].x >> a[i].y;
		
		// static int cc;
		// cc++;
		// if (cc == 75315)
		// {
		// 	cerr << n << endl;
		// 	for (int i = 0; i < n; i++)
		// 		cerr << a[i].x << " " << a[i].y << endl;
		// }
		
		cout << fixed << setprecision(10) << max(solve1(n), solve2(n)) << "\n";
	}
	
	return 0;
}
// started coding at: 06-04 17:50:44