#include <bits/stdc++.h>
#define ll long long
using namespace std;
const int N = 1e5 + 5;

const double pi = acos(-1.0);
const double eps = 1e-8;

// 判断 x 的大小，<0 返回 -1，>0 返回 1，==0 返回 0
int sgn(double x) {
    if (fabs(x) < eps) return 0;
    else return x < 0 ? -1 : 1;
}

// 比较两个浮点数
int dcmp(double x, double y) {
    if (fabs(x - y) < eps) return 0;
    else return x < y ? -1 : 1;
}

struct Point {
    double x, y;
    Point() {}
    Point(double x, double y) : x(x), y(y) {}

    Point operator + (const Point& B) const { return Point(x + B.x, y + B.y); }
    Point operator - (const Point& B) const { return Point(x - B.x, y - B.y); }
    Point operator * (double k) const { return Point(x * k, y * k); }
    Point operator / (double k) const { return Point(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(x - B.x) == 0 && sgn(y - B.y) < 0;
    }
};
typedef Point Vector;

class Geometry {
public:
    static double Distance(const Point& A, const Point& B) {
        return sqrt((A.x - B.x) * (A.x - B.x) + (A.y - B.y) * (A.y - B.y));
    }

    static double Dot(const Vector& A, const Vector& B) {
        return A.x * B.x + A.y * B.y;
    }

    static int AngleJudge(const Vector& A, const Vector& B) {
        return sgn(Dot(A, B));
    }

    static double Len(const Vector& A) {
        return sqrt(Dot(A, A));
    }

    static double Len2(const Vector& A) {
        return Dot(A, A);
    }

    static double Angle(const Vector& A, const Vector& B) {
        return acos(Dot(A, B) / Len(A) / Len(B));
    }

    static double Cross(const Vector& A, const Vector& B) {
        return A.x * B.y - A.y * B.x;
    }

    static double Area2(const Point& A, const Point& B, const Point& C) {
        return Cross(B - A, C - A);
    }

    static double AreaTriangle(const Point& A, const Point& B, const Point& C) {
        return Area2(A, B, C) / 2;
    }

    static Vector Rotate(const Vector& A, double rad) {
        return Vector(A.x * cos(rad) - A.y * sin(rad), A.x * sin(rad) + A.y * cos(rad));
    }

    static Vector Normal(const Vector& A) {
        double len = Len(A);
        return Vector(-A.y / len, A.x / len);
    }

    static bool Parallel(const Vector& A, const Vector& B) {
        return sgn(Cross(A, B)) == 0;
    }
};

class PolygonOps {
  public:
    static ll Area(int n, Point* ch) {
        ll area = 0;
        for (int i = 0; i < n; i++)
            area += Geometry::Cross(ch[i], ch[(i + 1) % n]);
        return area;
    }
};

int Convex_hull(Point* p, int n, Point* ch) {
    sort(p, p + n);
    int v = 0;
    for (int i = 0; i < n; i++) {
        while (v > 1 && sgn(Geometry::Cross(ch[v - 1] - ch[v - 2], p[i] - ch[v - 1])) <= 0) {
            v--;
        }
        ch[v++] = p[i];
    }
    int j = v;
    for (int i = n - 1; i >= 0; i--) {
        while (v > j && sgn(Geometry::Cross(ch[v - 1] - ch[v - 2], p[i] - ch[v - 1])) <= 0) {
            v--;
        }
        ch[v++] = p[i];
    }
    if (n > 1) v--;
    return v;
}

int n, n_left, m;
Point p[N], Left[N];
Point ch[N], chL[N], ch_sorted[N];

void solve() {
    cin >> n;
    n_left = m = 0;
    for (int i = 0; i < n; i++) {
        cin >> p[i].x >> p[i].y;
    }
    int v = Convex_hull(p, n, ch);
    set<Point> st;
    for (int i = 0; i < v; i++) {
        st.emplace(ch[i]);
    }
    for (int i = 0; i < n; i++) {
        if (!st.count(p[i])) {
            Left[n_left++] = p[i];
        }
    }
    int vL = Convex_hull(Left, n_left, chL);
    if (vL == 0) {
        cout << -1 << '\n';
        return;
    }
    // cerr << "v: " << v << '\n';
    // cerr << "vL: " << vL << ", n_left: " << n_left << '\n';
    ll area = PolygonOps::Area(v, ch);
    ll ans = 0;
    ch[v] = ch[0];
    chL[vL] = chL[0];
    for (int i = 0, j = 0; i < v; i++) {
        ll tri_0, tri_1;
        int cnt = 0;
        while (cnt < v &&
            (tri_0 = Geometry::Area2(chL[j], ch[i], ch[i + 1])) >=
            (tri_1 = Geometry::Area2(chL[j + 1], ch[i], ch[i + 1]))) {
            j = (j + 1) % vL;
            cnt++;
        }
        ans = std::max(ans, area - tri_0);
    }
    cout << ans << '\n';
}
int main() {
    ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
    int _T = 1;
    cin >> _T;
    while (_T--)
        solve();
    return 0;
}