#include <bits/stdc++.h>

using namespace std;

#ifdef LOCAL
#include "../debug.h"
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
#define debug(...) 42
#endif

using ll = long long;
using lf = long double;

const lf EPS = 1e-8L;
const lf E0 = 0.0L;//Keep = 0 for integer coordinates, otherwise = EPS
const lf INF = 5e9;

enum {OUT,IN,ON};

struct pt {
  lf x,y;
  pt(){}
  pt(lf a , lf b): x(a), y(b){}

  pt operator - (const pt &q ) const {
    return {x - q.x , y - q.y };
  }

  pt operator + (const pt &q ) const {
    return {x + q.x , y + q.y };
  }

  pt operator * (const lf &t ) const {
    return {x * t , y * t };
  }

  pt operator / (const lf &t ) const {
    return {x / t , y / t };
  }

  bool operator < ( const pt & q ) const {
    if( fabsl( x - q.x ) > E0 ) return x < q.x;
    return y < q.y;
  }

  void normalize() {
    lf norm = hypotl( x, y );
    if( fabsl( norm ) > EPS )
      x /= norm, y /= norm;
  }
};

pt rot90( pt p ) { return { -p.y, p.x }; }
pt rot( pt p, lf w ) {
  return { cosl( w ) * p.x - sinl( w ) * p.y, sinl( w ) * p.x + cosl( w ) * p.y };
}

lf norm2 ( pt p ) { return p.x * p.x + p.y * p.y; }
lf dis2 ( pt p, pt q ) { return norm2(p-q); }

lf norm ( pt p ) { return hypotl ( p.x, p.y ); }
lf dis( pt p, pt q ) { return norm( p - q ); }

lf dot( pt p, pt q ) { return p.x * q.x + p.y * q.y; }
ll cross( pt p, pt q ) { return p.x * q.y - q.x * p.y ; }

lf orient( pt a, pt b, pt c ) { return cross( b - a, c - a ); };

lf angle( pt a, pt b){ return atan2(cross(a, b), dot(a, b)); }

lf abs(pt a) { return sqrt(a.x * a.x + a.y * a.y); }

bool in_angle( pt a, pt b, pt c, pt p ) {
  //assert( fabsl( orient( a, b, c ) ) > E0 );
  if( orient( a, b, c ) < -E0 )
    return orient( a, b, p ) >= -E0 || orient( a, c, p ) <= E0;
  return orient( a, b, p ) >= -E0 && orient( a, c, p ) <= E0;
}

struct line {
  pt nv;
  lf c;

  line( pt _nv, lf _c ) : nv( _nv ), c( _c ) {}

  line ( pt p, pt q ) {
    nv = { p.y - q.y, q.x - p.x };
    c = -dot( p, nv );
  }

  lf eval( pt p ) { return dot( nv, p ) + c; }

  lf distance2( pt p ) {
    return eval( p ) / norm2( nv ) * eval( p );
  }

  lf distance( pt p ) {
    return fabsl( eval( p ) ) / norm( nv );
  }

  pt projection( pt p ) {
    return p - nv * ( eval( p ) / norm2( nv ) );
  }
};

vector< pt > convex_hull( vector< pt > v ) {
  sort( v.begin(), v.end() );//remove repeated points if needed
  const int n = v.size();
  if( n < 3 ) return v;
  vector< pt > ch( 2 * n );

  int k = 0;
  for( int i = 0; i < n; ++ i ) {
    while( k > 1 && orient( ch[k-2], ch[k-1], v[i] ) <= E0 )
      --k;
    ch[k++] = v[i];
  }

  const int t = k;
  for( int i = n - 2; i >= 0; -- i ) {
    while( k > t && orient( ch[k-2], ch[k-1], v[i] ) <= E0 )
      --k;
    ch[k++] = v[i];
  }
  ch.resize( k - 1 );
  return ch;
}

void Test(){
  int n;
  cin >> n;
  vector<pt> a(n);
  set<pt> st;
  for(int i = 0; i < n; ++i){
    int x, y;
    cin >> x >> y;
    a[i] = {x,y};
    st.insert(a[i]);
  }
  vector<pt> h1 = convex_hull(a);
  for(auto& i : h1){
    st.erase(i);
  }
  a.clear();
  for(auto& i : st){
    a.push_back(i);
  }
  vector<pt> h2 = convex_hull(a);
  n = h1.size();
  int m = h2.size();
  if( m == 0 ){
    cout << -1 << '\n';
    return;
  }
  for(int i = 0; i < 2 * n; ++i){
    h1.push_back(h1[i]);
  }
  for(int i = 0; i < 2 * m; ++i){
    h2.push_back(h2[i]);
  }
  line l1(h1[0],h1[1]);
  lf d = 4e18;
  int idx = -1;
  for(int i = 0; i < m; ++i){
    lf nd = l1.distance2(h2[i]);
    if( d > nd ){
      idx = i;
      d = l1.distance2(h2[i]);
    }
  }
  ll area = 0;
  for(int i = 0; i < n; ++i){
    area += cross(h1[i], h1[i + 1]);
  }
  ll ans = 0;
  int j = idx;
  for(int i = 0; i < 2 * n; ++i){
    line l(h1[i],h1[i + 1]);
    lf dis = l.distance2(h2[j]);
    ans = max(ans, abs(area - cross(h1[i], h1[i + 1]) + cross(h1[i],h2[j]) + cross(h2[j],h1[i + 1])));
    while( j < 3 * m && l.distance2(h2[j + 1]) < dis ){
      ++j;
      dis = l.distance2(h2[j]);
      ans = max(ans, abs(area - cross(h1[i], h1[i + 1]) + cross(h1[i],h2[j]) + cross(h2[j],h1[i + 1])));
    }
    ans = max(ans, abs(area - cross(h1[i], h1[i + 1]) + cross(h1[i],h2[j]) + cross(h2[j],h1[i + 1])));
  }
  cout << ans << '\n';
}

int main(){
  ios_base::sync_with_stdio(0);
  cin.tie(0);
  line l1(pt(0,0),pt(1,0));
  int T;
  cin >> T;
  while(T--){
    Test();
  }
  return 0;
}