#include <bits/stdc++.h>
using namespace std;
using i64 = long long;
using f64 = double;
const double eps = 1e-9;

template <class T>
bool eq(T a, T b) { return abs(a - b) < eps; }  // ==
template <class T>
bool gt(T a, T b) { return a - b > eps; }  // >
template <class T>
bool lt(T a, T b) { return a - b < -eps; }  // <
template <class T>
bool ge(T a, T b) { return a - b > -eps; }  // >=
template <class T>
bool le(T a, T b) { return a - b < eps; }  // <=



template <class T>
struct Point {
    T x, y;
    Point(T x_ = 0, T y_ = 0) : x(x_), y(y_) {}
    template <class U>
    operator Point<U>() { return Point<U>(U(x), U(y)); }
    Point& operator+=(Point p) & { x += p.x, y += p.y;return *this; }
    Point& operator-=(Point p) & { x -= p.x, y -= p.y;return *this; }
    Point& operator*=(T v) & { x *= v, y *= v;return *this; }
    Point operator-() const { return Point(-x, -y); }
    friend Point operator+(Point a, Point b) { return a += b; }
    friend Point operator-(Point a, Point b) { return a -= b; }
    friend Point operator*(Point a, T b) { return a *= b; }
    friend Point operator*(T a, Point b) { return b *= a; }
    friend bool operator==(Point a, Point b) { return a.x == b.x && a.y == b.y; }
    friend bool operator!=(Point a, Point b) { return !(a == b); }
    friend bool operator<(Point a, Point b) {
        if(eq(a.x, b.x)) return lt(a.y, b.y);
        return lt(a.x, b.x);
    }
    friend istream &operator>>(istream &is, Point& p) { return is >> p.x >> p.y; }
    friend ostream &operator<<(ostream &os, Point p) { return os << "(" << p.x << ", " << p.y << ")"; }
};
template <class T>
using Vec = Point<T>;

template <class T>
struct Line {
    Point<T> a, b;
    Line(Point<T> a_ = Point<T>(), Point<T> b_ = Point<T>()) : a(a_), b(b_) {}
};
template <class T>
using Seg = Line<T>;

// 点乘
template <class T>
T dot(Vec<T> a, Vec<T> b) { return a.x * b.x + a.y * b.y; }

// 模长平方
template <class T>
T square(Vec<T> p) { return dot(p, p); }

// 叉乘
template <class T>
T cross(Vec<T> a, Vec<T> b) { return a.x * b.y - a.y * b.x; }

// 向量长度
// square
template <class T>
double len(Vec<T> p) { return sqrt(double(square(p))); }

// 求凸包
template <class T>
vector<Point<T>> hull(vector<Point<T>> p) {
    vector<Point<T>> h, l;
    sort(p.begin(), p.end(), [&](auto a, auto b) {
        if (a.x != b.x) {
            return a.x < b.x;
        } else {
            return a.y < b.y;
        }
    });
    p.erase(unique(p.begin(), p.end()), p.end());
    if (p.size() <= 1) {
        return p;
    }

    for (auto a : p) {
        while (h.size() > 1 && le(cross(a - h.back(), a - h[h.size() - 2]), (T)0)) {
            h.pop_back();
        }
        while (l.size() > 1 && ge(cross(a - l.back(), a - l[l.size() - 2]), (T)0)) {
            l.pop_back();
        }
        l.push_back(a);
        h.push_back(a);
    }

    l.pop_back();
    reverse(h.begin(), h.end());
    h.pop_back();
    l.insert(l.end(), h.begin(), h.end());
    return l;
}

// 直线相交
template <class T>
Point<T> inter(Line<T> l1, Line<T> l2) {
    return l1.a + (l1.b - l1.a) * (cross(l2.b - l2.a, l1.a - l2.a) / cross(l2.b - l2.a, l1.a - l1.b));
}

// 点到线段最近点
template <class T>
Point<T> closet_seg(Point<T> p, Line<T> l) {
    auto t = p;
    t.x += l.a.y - l.b.y;
    t.y += l.b.x - l.a.x;
    if (gt(cross(l.a - p, t - p) * cross(l.b - p, t - p), (T)0)) {
        return lt(dis(p, l.a), dis(p, l.b)) ? l.a : l.b;
    }
    return inter(Line<T>(p, t), l);
}

// 线段间最近距离
template <class T>
T dis_seg(Seg<T> s1, Seg<T> s2) {
    return min(min(closet_seg(s1.a, s2), closet_seg(s1.b, s2), 
                min(closet_seg(s2.a, s1), closet_seg(s2.b, s1))));
}

template <class T>
i64 area_t(Point<T> p, Seg<T> s) {
    return abs(cross(s.a - p, s.b - p));
};

template <class T>
i64 RotateCalipers(vector<Point<T>> P1, vector<Point<T>> P2) {
    int n = P1.size(), m = P2.size();
    int j = 0;
    i64 res = LONG_LONG_MAX;
    for(int i = 0; i < n; i++) {
        auto u = P1[i], v = P1[(i + 1) % n];
        while(abs(cross(u - P2[(j + 1) % m], v - P2[(j + 1) % m])) < 
              abs(cross(u - P2[j], v - P2[j]))) j = (j + 1) % m;
        res = min(res, area_t(P2[j], {u, v}));
    }
    return res;
}

template <class T> 
i64 calculateArea(const vector<Point<T>>& P) {
    int n = P.size();
    i64 area = 0;
    for (int i = 0; i < n; i++) {
        int j = (i + 1) % n;
        area += cross(P[i], P[j]);
    }
    return area;
}

template<typename T>
struct std::hash<Point<T>> {
    size_t operator()(const Point<T>& p) const noexcept {  // 添加 noexcept
        return std::hash<T>()(p.x) ^ (std::hash<T>()(p.y) << 1);
    }
};


void solve() {
    int n;
    cin >> n;
    vector<Point<i64>> P(n);
    for(auto &i : P) cin >> i;
    auto tu1 = hull(P);
    vector<Point<i64>> left;
    unordered_set<Point<i64>> tu1_set(tu1.begin(), tu1.end());
    for(int i = 0; i < n; i++) {
        if(tu1_set.find(P[i]) == tu1_set.end()) {
            left.push_back(P[i]);
        }
    }
    auto tu2 = hull(left);
    i64 Area = abs(calculateArea(tu1));
    if(tu2.size() == 0) {
        cout << "-1\n";
        return;
    }
    if(tu2.size() <= 2) {
        i64 d = LONG_LONG_MAX;
        for(int i = 0; i < tu2.size(); i++) {
            for(int j = 0; j < tu1.size(); j++) {
                d = min(area_t(tu2[i], {tu1[j], tu1[(j + 1) % tu1.size()]}), d);
            }
        }
        cout << (i64)(Area - d) << '\n';
        return;
    }
    i64 ans = RotateCalipers(tu1, tu2);
    cout << (i64)(Area - 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;
}