#include <bits/stdc++.h>
#define eb emplace_back
using namespace std;
typedef long long ll;

// Structure to represent a point
struct P {
    ll x, y;
    P(ll x_=0, ll y_=0) : x(x_), y(y_) {}
    
    // Operator for sorting
    bool operator<(const P& other) const {
        return x < other.x || (x == other.x && y < other.y);
    }
};

// Cross product of OA and OB vectors
ll cross(const P& O, const P& A, const P& B) {
    ll dx1 = A.x - O.x;
    ll dy1 = A.y - O.y;
    ll dx2 = B.x - O.x;
    ll dy2 = B.y - O.y;
    return dx1 * dy2 - dx2 * dy1;
}

// Function to compute the convex hull using Andrew's algorithm
vector<P> convex_hull(vector<P> pts) {
    int n = pts.size();
    if(n == 0) return {};
    sort(pts.begin(), pts.end());
    // Remove duplicates if any (though problem states all points are distinct)
    pts.erase(unique(pts.begin(), pts.end(), [&](const P& a, const P& b) -> bool {
        return a.x == b.x && a.y == b.y;
    }), pts.end());
    
    n = pts.size();
    if(n == 1) return pts;
    
    vector<P> hull;
    // Lower hull
    for(int i = 0; i < n; ++i){
        while(hull.size() >=2 && cross(hull[hull.size()-2], hull[hull.size()-1], pts[i]) <= 0){
            hull.pop_back();
        }
        hull.eb(pts[i]);
    }
    // Upper hull
    int lower_size = hull.size();
    for(int i = n-2; i >=0 ; --i){
        while(hull.size() > lower_size && cross(hull[hull.size()-2], hull[hull.size()-1], pts[i]) <= 0){
            hull.pop_back();
        }
        hull.eb(pts[i]);
    }
    // Remove the last point because it's the same as the first one
    if(hull.size() >1) hull.pop_back();
    return hull;
}

// Function to compute twice the area of a polygon
ll polygon_area_twice(const vector<P>& poly){
    ll area = 0;
    int n = poly.size();
    for(int i=0;i<n;i++){
        int j = (i+1)%n;
        area += poly[i].x * poly[j].y - poly[j].x * poly[i].y;
    }
    return abs(area);
}

inline void work(){
    int n;
    cin >> n;
    vector<P> points(n);
    for(int i=0;i<n;i++) cin >> points[i].x >> points[i].y;
    
    // Compute Convex Hull CH1
    vector<P> CH1 = convex_hull(points);
    if((int)CH1.size() == n){
        // All points are on convex hull, cannot form concave polygon
        cout << "-1\n";
        return;
    }
    
    // Collect interior points
    // To efficiently find interior points, mark CH1 points
    // First, sort CH1 for binary search
    vector<P> sorted_CH1 = CH1;
    sort(sorted_CH1.begin(), sorted_CH1.end(), [&](const P& a, const P& b) -> bool {
        return a.x < b.x || (a.x == b.x && a.y < b.y);
    });
    // Collect interior points
    vector<P> interior;
    for(auto &pt : points){
        // Binary search in sorted_CH1
        if(!binary_search(sorted_CH1.begin(), sorted_CH1.end(), pt, [&](const P& a, const P& b) -> bool {
            return (a.x < b.x) || (a.x == b.x && a.y < b.y);
        })){
            interior.eb(pt);
        }
    }
    
    if(interior.empty()){
        // No interior points, cannot form concave polygon
        cout << "-1\n";
        return;
    }
    
    // Compute Convex Hull of interior points (CH2)
    vector<P> CH2 = convex_hull(interior);
    
    // To handle cases where CH2 has less than 3 points
    // Even with one or two points, we can still select them as potential x
    // So no special handling is needed since |ab cross (x -a)| can be computed for any x
    
    // Compute twice the area of CH1
    ll CH1_area_twice = polygon_area_twice(CH1);
    
    // Initialize minimum decrease in area
    ll min_decrease = LLONG_MAX;
    
    // Iterate over each edge ab in CH1
    int m = CH1.size();
    for(int i=0;i<m;i++){
        P a = CH1[i];
        P b = CH1[(i+1)%m];
        // For each edge ab, find the minimal |ab cross (x -a)| over all x in CH2
        // Since CH2 is convex, we can use ternary search to find the minimal value
        // However, the minimal value could be at any point, so it's safer to iterate all points in CH2
        // Given the constraints, this should be acceptable
        ll ab_dx = b.x - a.x;
        ll ab_dy = b.y - a.y;
        for(auto &x : CH2){
            ll cross_val = abs(ab_dx * (x.y - a.y) - ab_dy * (x.x - a.x));
            if(cross_val < min_decrease){
                min_decrease = cross_val;
                // Early exit if we find the minimal possible value
                if(min_decrease == 1) break;
            }
        }
        if(min_decrease == 1) break;
    }
    
    // Now, the maximum area of concave polygon is CH1_area_twice - min_decrease
    ll result = CH1_area_twice - min_decrease;
    // Since the problem asks to output twice the area, and we have already maintained it as twice the area
    cout << result << "\n";
}

int main(){
    cin.tie(0);
    ios::sync_with_stdio(false);
    int t;
    cin >> t;
    while(t--) work();
}