#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef tuple<int, int, int> tii;

inline int rd() {
    int x = 0;
    bool f = 0;
    char c = getchar();
    for (; !isdigit(c); c = getchar()) f |= (c == '-');
    for (; isdigit(c); c = getchar()) x = x * 10 + (c ^ 48);
    return f ? -x : x;
}

#define eb emplace_back
#define all(s) (s).begin(), (s).end()
#define rep(i, a, b) for (int i = (a); i <= (b); ++i)
#define per(i, a, b) for (int i = (a); i >= (b); --i)

typedef long long T;

struct P {
    T x, y;
    P (T x = 0, T y = 0) : x(x), y(y) {}
    P operator + (const P &p) const {return {x + p.x, y + p.y};}
    P operator - (const P &p) const {return {x - p.x, y - p.y};}
    P operator * (const T &d) const {return {x * d, y * d};}

    T operator | (const P &p) const {return x * p.x + y * p.y;}
    T operator ^ (const P &p) const {return x * p.y - y * p.x;}

    bool operator == (const P &p) const {return (x == p.x && y == p.y);}
    bool operator < (const P &p) const {return x == p.x ? y < p.y : x < p.x;}
    int ori(const P &p) const {T t = (*this) ^ p; return (t > 0) - (t < 0);}

} zero;

vector<P> convexHull(vector<P> p) {
    if (p.size() < 3) return p;
    vector<P> st;
    sort(all(p));
    const auto check = [&](const P &u) {
        const auto back1 = st.back(), back2 = *prev(st.end(), 2);
        return (back1 - back2).ori(u - back2) <= 0;
    };
    for (const P &u : p) {
        while (st.size() > 1 && check(u)) st.pop_back();
        st.push_back(u);
    }
    size_t k = st.size();
    p.pop_back(); reverse(all(p));
    for (const P &u : p) {
        while (st.size() > k && check(u)) st.pop_back();
        st.push_back(u);
    }
    st.pop_back();
    return {st};
}

inline void work() {
    int n = rd();
    vector<P> p;
    rep(i, 1, n) {int x = rd(), y = rd(); p.eb(x, y);}
    vector<P> cov1 = convexHull(p);
    if (cov1.size() == p.size()) {puts("-1"); return;}
    ll tot = 0;
    for (int i = 0; i < cov1.size(); ++i)
        tot += (cov1[i] ^ cov1[i == cov1.size() - 1 ? 0 : i + 1]);
    tot = abs(tot);
    vector<P> tmp = cov1;
    sort(all(tmp));
    sort(all(p));
    vector<P> q;
    int ptr = 0;
    for (auto pt : p) {
        if (ptr < tmp.size() && tmp[ptr] == pt) {
            ++ptr; continue;
        }
        q.push_back(pt);
    }
    vector<P> cov2 = convexHull(q);
    ll mn = 9e18;
    ptr = 0;
    P dir = cov1[1] - cov1[0];
    rep(i, 0, cov2.size() - 1) {
        ll nw = abs(dir ^ (cov2[i] - cov1[0]));
        if (nw < mn) {mn = nw; ptr = i;}
    }
    rep(i, 0, cov1.size() - 1) {
        dir = cov1[i == cov1.size() - 1 ? 0 : i + 1] - cov1[i];
        ll nw = abs(dir ^ (cov2[ptr] - cov1[i]));
        while (true) {
            int nxt = (ptr == cov2.size() - 1 ? 0 : ptr + 1);
            ll nxtv = abs(dir ^ (cov2[nxt] - cov1[i]));
            if (nxtv >=  nw) break;
            nw = nxtv;
            ptr = nxt;
        }
        mn = min(mn, nw);
    }
    printf("%lld\n", tot - mn);
}

int main() {
    per(t, rd(), 1) work();
    return 0;
}