#include <bits/stdc++.h>

template <typename T>
struct Point {
    T x{}, y{};
    friend T operator*(const Point &lhs, const Point &rhs) {
        return lhs.x * rhs.y - rhs.x * lhs.y;
    }
    friend Point operator-(const Point &lhs, const Point &rhs) {
        return Point{lhs.x - rhs.x, lhs.y - rhs.y};
    }
    friend bool operator==(const Point &lhs, const Point &rhs) {
        return lhs.x == rhs.x && lhs.y == rhs.y;
    }
};

template <typename P>
auto make_hull(std::vector<P> p) {
    std::sort(p.begin(), p.end(), [&](auto a, auto b) {
        return a.x < b.x || (a.x == b.x && a.y < b.y);
    });

    std::vector<P> hi, lo;
    for (auto p : p) {
        while (hi.size() > 1 &&
            (hi.back() - hi[hi.size() - 2]) * (p - hi.back()) >= 0) {
            hi.pop_back();
        }
        while (!hi.empty() && hi.back().x == p.x) {
            hi.pop_back();
        }
        hi.push_back(p);
        while (lo.size() > 1 &&
            (lo.back() - lo[lo.size() - 2]) * (p - lo.back()) <= 0) {
            lo.pop_back();
        }
        if (lo.empty() || lo.back().x < p.x) {
            lo.push_back(p);
        }
    }
    return std::make_pair(hi, lo);
}

using i64 = int64_t;
using u64 = uint64_t;

std::mt19937_64 rng64(std::chrono::steady_clock::now().time_since_epoch().count());
const u64 M0 = rng64() | 7, M1 = rng64() | 1;

template <>
struct std::hash<Point<i64>> {
    u64 operator()(const Point<i64> &p) const {
        return (p.x + M0) * (p.y + M1);
    }
};

template <typename P>
std::vector<P> hull_wrapper(std::vector<P> p) {
    auto [hi, lo] = make_hull(p);
    
    std::reverse(hi.begin(), hi.end());
    if (hi.back() == lo.front()) hi.pop_back();
    for (auto p : hi) {
        if (p == lo.back()) continue;
        lo.push_back(p);
    }
    return lo;
}

void solve() {
    int n;
    std::cin >> n;

    std::vector<Point<i64>> p(n);
    for (auto &[x, y] : p) {
        std::cin >> x >> y;
    }

    auto outer = hull_wrapper(p);
    std::unordered_set<Point<i64>> st;
    for (auto p : outer) st.insert(p);

    std::vector<Point<i64>> np;
    for (auto p : p) {
        if (st.find(p) == st.end()) {
            np.push_back(p);
        }
    }
    if (np.empty()) {
        std::cout << "-1\n";
        return;
    }
    auto inner = hull_wrapper(np);

    // std::cout << "outer:\n";
    // for (auto [x, y] : outer) {
    //     std::cout << x << ' ' << y << '\n';
    // }
    // std::cout << "inner:\n";
    // for (auto [x, y] : inner) {
    //     std::cout << x << ' ' << y << '\n';
    // }

    int x = 0;
    auto move = [&](auto &f) {
        while (f(inner[(x + 1) % inner.size()]) < f(inner[x]))
            x = (x + 1) % inner.size();
        while (f(inner[(x - 1 + inner.size()) % inner.size()]) < f(inner[x]))
            x = (x - 1 + inner.size()) % inner.size();
    };

    i64 S = 0;    
    i64 ans = 9e18;
    for (int i = 0; i < outer.size(); ++i) {
        auto [x0, y0] = outer[i];
        auto [x1, y1] = outer[(i + 1) % outer.size()];

        auto f = [&](auto p) -> i64 {
            return (y0 - y1) * p.x + (x1 - x0) * p.y + x0 * y1 - x1 * y0;
        };
        move(f);

        S += outer[i] * outer[(i + 1) % outer.size()];
        ans = std::min(ans, f(inner[x]));
    }

    std::cout << S - ans << '\n';
}

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);

    int t;
    std::cin >> t;

    while (t--) {
        solve();
    }
}