#include <string>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;

const long long INF = 15LL << 59;

string to_string(const vector<int>& arr) {
	string res = "[";
	for (int i = 0; i < int(arr.size()); i++) {
		if (i != 0) {
			res += ", ";
		}
		res += to_string(arr[i]);
	}
	res += "]";
	return res;
}

class point {
public:
	long long x, y;
	point() : x(0), y(0) {}
	point(long long x_, long long y_) : x(x_), y(y_) {}
	bool operator==(const point& p) const { return x == p.x && y == p.y; }
	bool operator!=(const point& p) const { return x != p.x || y != p.y; }
	point& operator+=(const point& p) { x += p.x; y += p.y; return *this; }
	point& operator-=(const point& p) { x -= p.x; y -= p.y; return *this; }
	point& operator*=(long long v) { x *= v; y *= v; return *this; }
	point operator+(const point& p) const { return point(*this) += p; }
	point operator-(const point& p) const { return point(*this) -= p; }
	point operator*(long long v) const { return point(*this) *= v; }
	long long dot(const point& p) const { return x * p.x + y * p.y; }
	long long cross(const point& p) const { return x * p.y - y * p.x; }
	string to_string() const {
		return "(" + std::to_string(x) + ", " + std::to_string(y) + ")";
	}
};

enum { ONLINE_FRONT = -2, CLOCKWISE, ON_SEGMENT, COUNTER_CLOCKWISE, ONLINE_BACK };
int ccw(const point& z, const point& a, const point& b) {
	if ((a - z).cross(b - z) > 0) return COUNTER_CLOCKWISE;
	if ((a - z).cross(b - z) < 0) return CLOCKWISE;
	if ((a - z).dot(b - z) < 0) return ONLINE_BACK;
	if ((z - a).dot(b - a) < 0) return ONLINE_FRONT;
	return ON_SEGMENT;
}

vector<int> convex_hull(int n, const vector<point>& g) {
	if (g == vector<point>(n, g[0])) {
		return {0};
	}
	vector<int> ord(n);
	for (int i = 0; i < n; i++) {
		ord[i] = i;
	}
	sort(ord.begin(), ord.end(), [&](int a, int b) {
		return g[a].y != g[b].y ? g[a].y < g[b].y : g[a].x < g[b].x;
	});
	vector<int> st;
	for (int i = 0; i < 2; i++) {
		int base = st.size();
		for (int v0 : ord) {
			while (int(st.size()) >= base + 2) {
				int v1 = st[st.size() - 1];
				int v2 = st[st.size() - 2];
				int z = ccw(g[v0], g[v1], g[v2]);
				if (z == CLOCKWISE) {
					break;
				}
				st.pop_back();
			}
			st.push_back(v0);
		}
		st.pop_back();
		reverse(ord.begin(), ord.end());
	}
	return st;
}

long long solve(int N, const vector<point>& P) {
	// step #1. compute first layer
	vector<int> s1 = convex_hull(N, P);
	vector<bool> used(N, false);
	for (int i : s1) {
		used[i] = true;
	}
	if (used == vector<bool>(N, true)) {
		return -1; // P is convex
	}

	// step #2. compute second layer
	vector<point> Q;
	for (int i = 0; i < N; i++) {
		if (!used[i]) {
			Q.push_back(P[i]);
		}
	}
	vector<int> s2 = convex_hull(Q.size(), Q);

	// step #3. calculate area
	s1.push_back(s1[0]);
	long long area = 0;
	for (int i = 0; i < int(s1.size()) - 1; i++) {
		area += P[s1[i]].cross(P[s1[i + 1]]);
	}

	// step #4. calculate answer
	long long mindec = INF;
	for (int i = 0; i < int(s1.size()) - 1; i++) {
		point v = P[s1[i + 1]] - P[s1[i]];
		auto comp = [&](int x, int y) {
			return v.cross(Q[s2[x]] - P[s1[i]]) > v.cross(Q[s2[y]] - P[s1[i]]);
		};
		int a = 0, b = s2.size(), c = s2.size() * 2;
		while (abs(c - a) > 2) {
			if (abs(b - a) < abs(c - b)) {
				swap(a, c);
			}
			int s = (a + b) / 2;
			if (comp(s % s2.size(), b % s2.size())) {
				a = s;
			} else {
				c = b;
				b = s;
			}
		}
		int target = b % s2.size();
		long long reduce = v.cross(Q[s2[target]] - P[s1[i]]);
		mindec = min(mindec, reduce);
	}

	return area - mindec;
}

int main() {
	int T;
	cin >> T;
	for (int id = 1; id <= T; id++) {
		int N;
		cin >> N;
		vector<point> P(N);
		for (int i = 0; i < N; i++) {
			cin >> P[i].x >> P[i].y;
		}
		long long ans = solve(N, P);
		cout << ans << '\n';
	}
	return 0;
}