#include <bits/stdc++.h>
using namespace std;

typedef long long ll;

template <class T>
struct Point
{
    T x;
    T 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 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>
T dot(Point<T> a, Point<T> b)
{
    return a.x * b.x + a.y * b.y;
}

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

template <class T>
double distance(Point<T> a, Point<T> b)
{
    T xx = a.x - b.x, yy = a.y - b.y;
    return sqrtl(xx * xx + yy * yy);
}
template <class T>
T distance2(Point<T> a, Point<T> b)
{
    T xx = a.x - b.x, yy = a.y - b.y;
    return xx * xx + yy * yy;
}
template <class T>
T square(Point<T> p)
{
    return dot(p, p);
}

template <class T>
double length(Point<T> p)
{
    return sqrt(double(square(p)));
}

long double length(Point<long double> p)
{
    return sqrt(square(p));
}

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

template <class T>
Point<T> rotate(Point<T> a)
{
    return Point(-a.y, a.x);
}

template <class T>
int sgn(Point<T> a)
{
    return a.y > 0 || (a.y == 0 && a.x > 0) ? 1 : -1;
}

template <class T>
bool pointOnLineLeft(Point<T> p, Line<T> l)
{
    return cross(l.b - l.a, p - l.a) > 0;
}

template <class T>
Point<T> lineIntersection(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>
bool pointOnSegment(Point<T> p, Line<T> l)
{
    return cross(p - l.a, l.b - l.a) == 0 && min(l.a.x, l.b.x) <= p.x && p.x <= max(l.a.x, l.b.x) && min(l.a.y, l.b.y) <= p.y && p.y <= max(l.a.y, l.b.y);
}

void solve()
{
    int n;
    cin >> n;
    int x, y, r;
    cin >> x >> y >> r;

    vector<Point<int>> p(n);
    for (int i = 0; i < n; ++i)
        cin >> p[i].x >> p[i].y;

    ll ans = 0, res = 0;
    int pos = 0;
    for (int i = 0; i < n; ++i)
    {
        ll last = 0;
        while (true)
        {
            ll A = p[i].y - p[(pos + 1) % n].y, B = p[(pos + 1) % n].x - p[i].x, C = cross(p[i], p[(pos + 1) % n]);

            __int128_t le = A * x + B * y + C;
            if ((le > 0 && last < 0) || (le < 0 && last > 0))
                break;
            last = le;
            le = le * le;
            __int128_t re = 1ll * r * r;
            re *= A * A + B * B;
            if (le < re)
                break;

            res += cross(p[i] - p[pos], p[i] - p[(pos + 1) % n]);
            pos = (pos + 1) % n;
        }
        ans = max(ans, res);
        res -= cross(p[pos] - p[i], p[pos] - p[i + 1]);
    }
    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;
}