萌新 T3 写的可能是分块的结构，但是 $\texttt{Subtask 3}$ 死活过不去。

块长基本上都调完了，最快的也过不去。

求大佬帮调，如果分块是错误的，还求大佬说下正解

代码前面火车头，到 // -------- User Define Area -------- 是代码开始的地方。

#include <bits/stdc++.h>

const int maxn = 500005;

#define rep(m, l ,r) for (int m(l); m <= r; ++m)

namespace IO
{
    template <typename T> inline T read()
    {
        T fx = (T)1, xx = (T)0; char ch = getchar();
        while (!isdigit(ch)) { if (ch == '-') {fx = -1;} ch = getchar(); }
        while (isdigit(ch)) { xx *= 10; xx += ch - 48; ch = getchar(); }
        return fx * xx;
    }

    template <typename T> inline void write(T x)
    {
        if (x < 10) putchar(x + 48);
        else write(x / 10), putchar(x % 10 + 48);
        return;
    }

    inline void writeln() { putchar('\n'); return; }

    inline void enableFastStream() { std::ios::sync_with_stdio(0); std::cin.tie(0); std::cout.tie(0); }
};

namespace math
{
    template <typename T> inline T gcd(T a, T b) { if (b == 0) return a; else return gcd(b, a % b); }
    template <typename T> inline T exgcd(T a, T b, T &x, T &y)
    {
        if (b == 0) { x = 1, y = 0; return a; }
        else {T d = exgcd(b, a % b, x, y); T t = x, x = y, y = t - (a / b) * y; return d;}
    }
};

using namespace IO;
using namespace math;
using namespace std;

class edgeSet
{
    public:
        struct Edge { int to, next, val; };
        int head[maxn], cnt; Edge e[maxn];
        void add(int u, int v, int w = 0) { e[++cnt].to = v, e[cnt].val = w; e[cnt].next = head[u], head[u] = cnt; }
};

class Union
{
    public:
        int fa[maxn];
        inline int find(int x) { if (fa[x] == x) return x; else return fa[x] = find(fa[x]); }
        inline void init(int size_t) { for (int i(1); i <= size_t; ++i) fa[i] = i; }
        inline void merge(int x, int y) { fa[find(x)] = fa[find(y)]; }
        inline void check(int size_t) { for (int i(1); i <= size_t; ++i) fa[i] = find(fa[i]); }
        inline bool query(int x, int y) { if (find(fa[x]) == find(fa[y])) return true; else return false; }
};

// -------- User Define Area --------
struct node
{
    long long x, y;
    bool operator< (const node &xx) const
    {
        return x < xx.x;
    }
} lst[2000005];

#define maxn 31622
#define maxm 32000

vector<node> e[maxm];
long long ll[100000], rr[100000];
int maxcur = -1;
long long maxleft = 1e10, maxright = -1e10;
// ----------------------------------

bool greaTer(node xx, node yy)
{
    return xx.y < yy.y;
}

int main()
{
    int t = read<int>();
    while (t--)
    {
        for (int i(0); i <= maxcur; ++i)
            e[i].clear();
        maxcur = -1;
        int n = read<int>();
        rep(i, 1, n)
        {
            lst[i].x = read<long long>(), lst[i].y = abs(read<long long>());
            int cur = lst[i].y / maxn;
            maxleft = lst[i].x < maxleft ? lst[i].x : maxleft;
            maxright = lst[i].x > maxright ? lst[i].x : maxright;
            maxcur = cur > maxcur ? cur : maxcur;
            e[cur].push_back(lst[i]);
        }
        sort(lst + 1, lst + n + 1, greaTer);
        rep(i, 0, maxcur)
        {
            if (e[i].empty())
                continue;
            sort(e[i].begin(), e[i].end());
            ll[i] = e[i][0].x, rr[i] = e[i][e[i].size() - 1].x;
        }
        long long cur = -1;
        for (register int k(n); k; --k)
        {
            if (lst[k].y * (maxright - maxleft) < cur)
                break;
            int now = lst[k].y / maxn;
            rep(i, now + 1, maxcur)
            {
                if (e[i].empty())
                    continue;
                long long cur1 = (rr[i] - lst[k].x) * lst[k].y;
                long long cur2 = (lst[k].x - ll[i]) * lst[k].y;
                cur = cur1 > cur ? cur1 : cur;
                cur = cur2 > cur ? cur2 : cur;
            }
            if ( ( (rr[now] - lst[k].x) * lst[k].y < cur ) && ( (lst[k].x - ll[now]) * lst[k].y < cur ) )
                continue;
            for (int i(0); i < e[now].size(); ++i)
            {
                if (e[now][i].y < lst[k].y)
                    continue;
                long long cur1 = abs(e[now][i].x - lst[k].x) * lst[k].y;
                cur = cur1 > cur ? cur1 : cur;
            }
        }
        write(cur); writeln();
    }   
    return 0;
}