#include<bits/stdc++.h>
using namespace std;

namespace ModInt{
	template <uint32_t mod>
	struct mint
	{
		#define i32 int32_t
		#define u32 uint32_t
		#define u64 uint64_t
		static constexpr u32 get_r(){u32 ret=mod;for(i32 i=0;i<4;++i)ret*=2-mod*ret;return ret;}
		static constexpr u32 r=get_r();
		static const u32 n2=-u64(mod)%mod;
		static const u32 mod2=mod<<1;
		u32 a;
		constexpr mint():a(0){}
		constexpr mint(const int64_t &b):a(reduce(u64(b%mod+mod)*n2)){};
		static constexpr u32 reduce(const u64 &b){return (b+u64(u32(b)*u32(-r))*mod)>>32;}
		const mint &operator+=(const mint &b){if(i32(a+=b.a-mod2)<0)a+=mod2;return *this;}
		const mint &operator-=(const mint &b){if(i32(a-=b.a)<0)a+=mod2;return *this;}
		const mint &operator*=(const mint &b){a=reduce(u64(a)*b.a);return *this;}
		const mint &operator/=(const mint &b){*this*=b.inverse();return *this;}
		const mint operator+(const mint &b)const{return mint(*this)+=b;}
		const mint operator-(const mint &b)const{return mint(*this)-=b;}
		const mint operator*(const mint &b)const{return mint(*this)*=b;}
		const mint operator/(const mint &b)const{return mint(*this)/=b;}
		const bool operator==(const mint &b)const{return(a>=mod?a-mod:a)==(b.a>=mod?b.a-mod:b.a);}
		const bool operator!=(const mint &b)const{return(a>=mod?a-mod:a)!=(b.a>=mod?b.a-mod:b.a);}
		const mint operator-()const{return mint()-mint(*this);}
		const mint ksm(u64 n)const{mint ret(1);for(mint mul(*this);n;n>>=1,mul*=mul)if(n&1)ret*=mul;return ret;}
		const mint inverse()const{return ksm(mod-2);}
		friend ostream &operator<<(ostream &os, const mint &b){return os<<b.get();}
		friend istream &operator>>(istream &is, mint &b){int64_t t;is>>t;b=mint(t);return(is);}
		const u32 get()const{u32 ret=reduce(a);return ret>=mod?ret-mod:ret;}
		static const u32 get_mod(){return mod;}
	};
}
using namespace ModInt;

namespace FAST_IO{
	#define ll long long
	#define ull unsigned long long
	#define db double
	#define _8 __int128_t
	#define Get() (BUF[Pin++])
	const int LEN=1<<20;
	char BUF[LEN];
	int Pin=LEN;
	inline void flushin(){memcpy(BUF,BUF+Pin,LEN-Pin),fread(BUF+LEN-Pin,1,Pin,stdin),Pin=0;return;}
	inline char Getc(){return (Pin==LEN?(fread(BUF,1,LEN,stdin),Pin=0):0),BUF[Pin++];}
	template<typename tp>inline tp read(){(Pin+40>=LEN)?flushin():void();tp res=0;char f=1,ch=' ';for(;ch<'0'||ch>'9';ch=Get())if(ch=='-')f=-1;for(;ch>='0'&&ch<='9';ch=Get())res=(res<<3)+(res<<1)+ch-48;return res*f;}
	template<typename tp>inline void read(tp &n){(Pin+40>=LEN)?flushin():void();tp res=0;char f=1,ch=' ';for(;ch<'0'||ch>'9';ch=Get())if(ch=='-')f=-1;for(;ch>='0'&&ch<='9';ch=Get())res=(res<<3)+(res<<1)+ch-48;n=res*f;return;}
	inline int readstr(char *s){int len=0;char ch=Getc();while(!isalnum(ch))ch=Getc();while(isalnum(ch))s[len++]=ch,ch=Getc();return len;}
	#define Put(x) (PUF[Pout++]=x)
	char PUF[LEN];
	int Pout;
	inline void flushout(){fwrite(PUF,1,Pout,stdout),Pout=0;return;}
	inline void Putc(char x){if(Pout==LEN)flushout(),Pout=0;PUF[Pout++]=x;}
	template<typename tp>inline void write(tp a,char b='\n'){static int stk[40],top;(Pout+50>=LEN)?flushout():void();if(a<0)Put('-'),a=-a;else if(a==0)Put('0');for(top=0;a;a/=10)stk[++top]=a%10;for(;top;--top)Put(stk[top]^48);Put(b);return;}
	inline void wt_str(string s){for(char i:s)Putc(i);return;}
}
using namespace FAST_IO;

#define pii pair<int,int>
#define fi first
#define se second
#define ls (rt<<1)
#define rs (rt<<1|1)
#define Ls (tr[rt].lc)
#define Rs (tr[rt].rc)

#define JH ll

const db eps = 1e-8;

int sgn(JH x)
{
	if(fabs(x) < eps) return 0;
	if(x < 0) return -1;
	return 1;
}

struct Point{
	JH x,y;
	Point(){}
	Point(JH _x, JH _y):x(_x),y(_y){}
	Point operator + (const Point b) const {
		return {x + b.x, y + b.y};
	}
	Point operator - (const Point b) const {
		return {x - b.x, y - b.y};
	}
	JH operator * (const Point b) const {
		return x * b.x + y * b.y;
	}
	JH operator ^ (const Point b) const {
		return x * b.y - y * b.x;
	} // a^b>0 则 b 在 a 的逆时针方向, 
	  //a^b<0 则 b 在 a 的顺时针方向, 
	  //a^b=0 则通过 a*b 判断同向或反向 
	  
	double dist(const Point b) const {
		return sqrtl((x - b.x) * (x - b.x) + (y - b.y) * (y - b.y));
	}
	Point operator * (const JH k) const {
		return {x * k, y * k};
	} 
	Point operator / (const JH k) const {
		return {x / k, y / k};
	} 
	bool operator == (const Point b) const{
		return sgn(x - b.x) == 0 && sgn(y - b.y) == 0;
	}
	bool operator < (const Point b) const {
		return sgn(x - b.x) == 0 ? sgn(y - b.y) < 0 : sgn(x - b.x) < 0;
	}
    ///逆时针旋转90度
    Point rotleft(){
        return {y,-x};
    }
    ///顺时针旋转90度
    Point rotright(){
        return {y,-x};
    }
};

struct Segment{
	Point a, b;
	Segment() {}
	Segment(Point _a, Point _b):a(_a), b(_b) {}
	
	bool ifPointOn(const Point p) const {
		return sgn( (p - a) ^ (b - a) ) == 0 && sgn( (p - a) * (p - b) ) <= 0;
	}
	
	double disPoint(const Point p) const {
		if( sgn( (p - a) * (b - a) ) < 0 || sgn ( (p - b) * (a - b) ) < 0)
			return min(p.dist(a), p.dist(b));
		return fabs( (p - a) ^ (b - a) ) / (p - a).dist({0, 0});
	}
	
	//2 规范相交
	//1 非规范相交
	//0 不相交 
	
	int crossSeg(const Segment v) const {
		int d1 = sgn((b - a) ^ (v.a - a));
		int d2 = sgn((b - a) ^ (v.b - a));
		int d3 = sgn((v.b - v.a) ^ (a - v.a));
		int d4 = sgn((v.b - v.a) ^ (b - v.a));
		if((d1 ^ d2) == -2 && (d3 ^ d4) == -2) return 2;
		
		return (d1 == 0 && sgn((v.a - a) * (v.a - b)) <= 0) ||
			   (d2 == 0 && sgn((v.b - a) * (v.b - b)) <= 0) ||
			   (d3 == 0 && sgn((a - v.a) * (a - v.b)) <= 0) ||
			   (d4 == 0 && sgn((b - v.a) * (b - v.b)) <= 0); 
	} 
	
	double disSeg(const Segment v) const {
		return min({disPoint(v.a), disPoint(v.b), v.disPoint(a), v.disPoint(b)});
	}
};

struct Line{
	Point a, b;
	Line() {}
	Line(Point _a, Point _b):a(_a), b(_b) {} 
	
	//-1 p 在 ab 左侧, 0 p 在 ab 上, 1 p 在 ab 右侧. 
	int relation(const Point p) const {
		return sgn( (p - a) ^ (b - a) );
	}
	// 点到直线距离 
	double disPoint(const Point p) const {
		return fabs( (p - a) ^ (b - a) ) / (p - a).dist({0, 0});
	}
};


// 求向量 a,b 的夹角 
double rad(Point a, Point b) // atan2(y,x) 返回 y/x 的反正切, 返回值为 [-pi,pi] 的一个值 
{
	return fabs(atan2(fabs(a^b),a*b));
}

//2 规范相交 1 非规范相交(端点处相交) 0 不相交 
int LineCrossSeg(Line a, Segment b)
{
	int d1 = sgn( (b.b - b.a) ^ (a.a - b.a) );
	int d2 = sgn( (b.b - b.a) ^ (a.b - b.a) );
	if( (d1 ^ d2) == -2 ) return 2;
	return (d1 == 0 || d2 == 0);
}

vector<Point> ConvexHull(vector<Point> &p,vector<int>&used)
{
	vector<Point>ans;
	vector<int>stk;
	int n = p.size();
	stk.resize(n+10);
	used.resize(n);
	int top = 0;
	sort(p.begin(),p.end());
	for(int i = 0; i < n; ++i)
	{
		while(top>=2 && sgn((p[stk[top]] - p[stk[top - 1]]) ^ (p[i] - p[stk[top]])) <= 0)
			used[stk[top--]] = 0;
		used[i] = 1;
		stk[++top] = i;
	}
	used[0]=0;
	int tmp = top;
	for (int i = n - 1; i >= 0; i--)
		if(!used[i])
		{
			while(top > tmp && sgn((p[stk[top]] - p[stk[top - 1]]) ^ (p[i] - p[stk[top]])) <= 0)
				used[stk[top--]] = 0;
			used[i] = 1;
			stk[++top] = i;
		}
	top--;
	for(int i = 1; i <= top; i++)
		ans.push_back(p[stk[i]]);
	return ans;
}
const int N=1e5+10;
vector<Point>p,p2,CH,CH2;
vector<int>used;
Point tmp;
int n,T;
ll ans,S;
ll get_S(int i,int j)
{
	return abs((CH[i]-CH2[j])^(CH[(i+1)%CH.size()]-CH2[j]));
}
int main()
{
//	freopen("B.in","r",stdin);
	read(T);
	while(T--)
	{
		p.clear();
		p2.clear();
		CH.clear();
		CH2.clear();
		used.clear();
		read(n);
		for(int i=1,x,y;i<=n;i++)
		{
			read(x),read(y);
			p.push_back({x,y});
		}
		CH=ConvexHull(p,used);
//		puts("1111");
//		for(int i=0;i<n;i++)
//			printf("%d",used[i]);
//		puts("");
		for(int i=0;i<n;i++)
			if(!used[i])
				p2.push_back(p[i]);
		used.clear();
		if(p2.size()==0)
		{
			write(-1);
			continue;
		}
		if(p2.size()>2)	CH2=ConvexHull(p2,used);
		else CH2=p2;
		S = 0;
//		puts("222");
		for(int i = 0; i < CH.size(); i++)
			S += CH[i] ^ CH[(i + 1) % CH.size()];
		S = abs(S);
//		printf("S:%lld\n",S);
		ans = 4e18;
//		puts("1:");
//		for(Point p:CH)
//			printf("%d %d\n",p.x,p.y);
//		printf("%d\n",CH2.size());
//		puts("2:");
//		for(Point p:CH2)
//			printf("%d %d\n",p.x,p.y);
		for(int i = 0,pp = 0; i < CH.size(); i++)
		{
			while(get_S(i,(pp+1)%CH2.size())<get_S(i,pp))
			{
				pp=(pp+1)%CH2.size();
			}
			
			while(get_S(i,(pp+CH2.size()-1)%CH2.size())<get_S(i,pp))
			{
				pp=(pp+CH2.size()-1)%CH2.size();
			}
//			printf("%d %d %lld %lld\n",i,pp,get_S(i,(pp+1)%CH2.size()),get_S(i,2));
			ans=min(ans,get_S(i,pp));
		}
		write(S-ans);
		
	} 
	flushout();
	return 0;
}
/*
2
6
-2 0
1 -2
5 2
0 4
1 2
3 1
4
0 0
1 0
0 1
1 1
*/