#include <iostream>
#include <algorithm>
#include <cstdio>
#include <queue>
#include <vector>
#include <unordered_set>
#include <functional>
#include <stack>
#include <set>
#include <cmath>
#include <climits>
#include <cstring>
using namespace std;

inline int read() {
    int x = 0, f = 1;
    char c = getchar();
    while (c > '9' || c < '0')
        f = c == '-' ? -1 : 1, c = getchar();
    while (c >= '0' && c <= '9')
        x = x * 10 + c - 48, c = getchar();
    return x * f;
}
using i64 = long long;
using pii = pair<int, int>;
using pll = pair<i64, i64>;

const int N=100010;
const double eps=1e-8;

struct point {
    i64 x,y;
    point(i64 x=0,i64 y=0):x(x),y(y) {};
};
#define point point
point operator + (point a,point b) {return point(a.x+b.x,a.y+b.y);}
point operator - (point a,point b) {return point(a.x-b.x,a.y-b.y);}
point operator * (point a,i64 k) {return point(a.x*k,a.y* k);}
point operator / (point a,i64 k) {return point(a.x/k,a.y/k);}
i64 operator * (point a,point b) {return a.x*b.x+a.y*b.y;}
i64 operator ^ (point a,point b) {return a.x*b.y-b.x*a.y;}
point d[N],hull_1[N],hull_2[N],tmp[N];
bool operator < (point a,point b) {return a.x==b.x?a.y<b.y:a.x<b.x;}

int n,m_1, m_2,id_1[N],id_2[N],vis[N];
// i64 len(point a) {return sqrt(a.x*a.x+a.y*a.y);}

void get_hull_1() {
    m_1 = 2;
    hull_1[1] = d[1], hull_1[2] = d[2];
    id_1[1] = 1, id_1[2] = 2;
    for (int i = 3; i <= n; ++i) {
        while (m_1 > 1 && (((hull_1[m_1] - hull_1[m_1 - 1]) ^ (d[i] - hull_1[m_1 - 1])) - eps < 0)) --m_1;
        hull_1[++m_1] = d[i];
        id_1[m_1] = i;
    }
    int k = m_1;
    for (int i = n - 1; i >= 1; --i) {
        while (m_1 > k && (((hull_1[m_1] - hull_1[m_1 - 1]) ^ (d[i] - hull_1[m_1 - 1])) - eps < 0)) --m_1;
        hull_1[++m_1] = d[i];
        id_1[m_1] = i;
    }
}

void get_hull_2() {
    m_2 = 2;
    hull_2[1] = d[1], hull_2[2] = d[2];
    id_2[1] = 1, id_2[2] = 2;
    for (int i = 3; i <= n; ++i) {
        while (m_2 > 1 && (((hull_2[m_2] - hull_2[m_2 - 1]) ^ (d[i] - hull_2[m_2 - 1])) - eps < 0)) --m_2;
        hull_2[++m_2] = d[i];
        id_2[m_2] = i;
    }
    int k = m_2;
    for (int i = n - 1; i >= 1; --i) {
        while (m_2 > k && (((hull_2[m_2] - hull_2[m_2 - 1]) ^ (d[i] - hull_2[m_2 - 1])) - eps < 0)) --m_2;
        hull_2[++m_2] = d[i];
        id_2[m_2] = i;
    }
}

int main() {
    // freopen("input.txt", "r", stdin);
    // freopen("output.txt", "w", stdout);
    int T = read();
    while (T--) {
        m_1 = m_2 = 0;
        memset(id_1,0,sizeof(id_1));
        memset(id_2,0,sizeof(id_2));
        memset(vis,0,sizeof(vis));

        n = read();
        for (int i = 1; i <= n; ++i)
            d[i].x = read(), d[i].y = read();
        sort(d + 1, d + n + 1);
        get_hull_1();

        if (n + 1 == m_1) {
            puts("-1");
            continue;
        }
        i64 sum = 0;
        for (int i = 1; i < m_1; ++i) {
            sum += hull_1[i] ^ hull_1[i + 1];
        }
        for (int i = 1; i <= m_1; ++i)
            vis[id_1[i]] = 1;
        int tmp_n = 0;
        for (int i = 1; i <= n; ++i)
            if (vis[i] == 0) {
                tmp[++tmp_n] = d[i];
            }
        n = tmp_n;
        for (int i = 1; i <= n; ++i)
            d[i] = tmp[i];
        d[n + 1] = d[1];
        sort(d + 1, d + n + 1);
        get_hull_2();

        // 1 ~ m_2-1 -> 1 ~ m_2-1 + 1 ~ m_2-1 + 1
        // 2 * (m_2 - 1) + 1 = 2 * m_2 - 1
        hull_2[m_2 * 2 - 1] = hull_2[1];
        for (int i = m_2; i < m_2 * 2 - 1; i++) {
            hull_2[i] = hull_2[i - m_2 + 1];
        }

        m_2 = 2 * m_2 - 1;
        i64 mn = LONG_MAX;
        for (int i = 1, j = 1; i <= m_1 - 1; i++) {
            auto st = hull_1[i], ed = hull_1[i + 1];
            i64 cur_mn = abs((st - hull_2[j]) ^ (ed - hull_2[j]));
            while (j < m_2 && abs((st - hull_2[j + 1]) ^ (ed - hull_2[j + 1])) < cur_mn) {
                cur_mn = abs((st - hull_2[j + 1]) ^ (ed - hull_2[j + 1]));
                j++;
            }
            mn = min(mn, cur_mn);
        }
        sum -= mn;
        cout << sum << endl;
    }
    return 0;
}