// Program written by EricWu ~~~
#include <bits/stdc++.h>
 
#define lowbit(x) (x & -x)
 
using namespace std;
 
inline char gc(void) {
    static char buf[100000], *p1 = buf, *p2 = buf;
    return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2) ? EOF : *p1++;
}
 
#define gc() getchar()
 
template <class T> inline void read(T &x) {
    T f = 1; x = 0; static char c = gc();
    for (; !isdigit(c); c = gc()) if (c == '-') f = -f;
    for (; isdigit(c); c = gc()) x = x * 10 + (c & 15);
    if (f == -1) x = -x;
}
 
inline void readstr(char *s) {
    do *s = gc(); while ((*s == ' ') || (*s == '\n') || (*s == '\r'));
    do *(++s) = gc(); while ((~*s) && (*s != ' ') && (*s != '\n') && (*s != '\r'));
    *s = 0; return;
}
 
inline void readch(char&x) { while (isspace(x = gc())); }
 
char pf[100000], *o1 = pf, *o2 = pf + 100000;
#define ot(x) (o1 == o2 ? fwrite(pf, 1, 100000, stdout), *(o1 = pf) ++= x : *o1 ++= x)
template <class T>
inline void println(T x, char c = '\n') {
    if (x < 0) ot(45), x = -x;
    static char s[15], *b; b = s;
    if (!x) *b ++= 48;
    for (; x; * b ++= x % 10 + 48, x /= 10);
    for (; b-- != s; ot(*b)); ot(c);
}
 
template <class T> inline void write(T x) {
    if (x < 0) x = -x, putchar('-');
    if (x > 9) write(x / 10);
    putchar(x % 10 + 48);
}
 
template <class T> inline void writeln(T x, char c = '\n') { write(x); putchar(c); }
template <class T> inline void chkmax(T &x, const T y) { x > y ? x = x : x = y; }
template <class T> inline void chkmin(T &x, const T y) { x < y ? x = x : x = y; }
 
#define Ms(arr, opt) memset(arr, opt, sizeof(arr))
#define Mp(x, y) make_pair(x, y)
#define endl '\n'

typedef long long ll;
typedef pair <int, int> pii;
typedef array<int, 3> piii;
using i64 = long long;
const int inf = 1e9;

const double eps = 1e-9;
const long double PI = acos(-1.0);
struct Point {
    i64 x, y;
    Point(i64 x = 0, i64 y = 0) : x(x), y(y) {}
};
ostream& operator<<(ostream &os, const Point &p) {return os << p.x << " " << p.y;}
typedef Point Vector;

Vector operator+(const Vector &p1, const Vector &p2) {return Vector(p1.x + p2.x, p1.y + p2.y);}
Vector operator-(const Vector &p1, const Vector &p2) {return Vector(p1.x - p2.x, p1.y - p2.y);}
bool operator==(const Point &p1, const Point &p2) {return p1.x == p2.x && p1.y == p2.y;}
bool operator<(const Point &p1, const Point &p2) {return p1.x < p2.x || (p1.x == p2.x && p1.y < p2.y);}
i64 Cross(const Vector &a, const Vector &b) {return a.x * b.y - a.y * b.x;}
double Dist(const Point &a, const Point &b) {
    return sqrt(1.0 * (a.x - b.x) * (a.x - b.x) + 1.0 * (a.y - b.y) * (a.y - b.y));
}
Vector Rotate(const Vector &a, const double rad) {
    return Vector(a.x * cos(rad) - a.y * sin(rad), a.x * sin(rad) + a.y * cos(rad));
}
i64 Dot(const Vector &a, const Vector &b) { return a.x * b.x + a.y * b.y;}
double Length(const Vector& a) {return sqrt(1.0 * Dot(a, a)); }
double Angle(const Vector &a, const Vector &b) {
    return asin(Cross(a, b) / Length(a) / Length(b));
}
int dcmp(long double a) {if (fabs(a) <= eps) return 0; return a > 0 ? 1 : -1;}
int dcmp(double a, double b) {
    if (fabs(a - b) <= eps) return 0;
    return a > b ? 1 : -1;
}
i64 Area(const Point &a, const Point &b, const Point &c) {
    Vector u = a - b, v = a - c;
    return abs(Cross(u, v));
}
i64 Dist2(const Point &a, const Point &b) {
    return (a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y);
}
bool cmp(const Point &a, const Point &b, const Point &c, int r1) {
    __int128_t area = Area(a, b, c);
    __int128_t len = Dist2(a, b);
    if (area >= r1 * len) return true;
    return false;
}

void solve() {
    int n; read(n); 
    int x1, y1, r1; read(x1), read(y1), read(r1);
    Point p1(x1, y1);
    vector<Point> p(2 * n);
    for (int i = 0;i < n;i++) read(p[i].x), read(p[i].y);
    for (int i = n;i < 2 * n;i++) p[i] = p[i - n];
    int ans = 0; int k = 2;
    for (int i = 0;i < 2 * n;i++) {
        int j = i + 1; k = max(k, i + 2);
        if (!(cmp(p[i], p[j], p1, r1) || cmp(p[i], p[j], p1, r1))) continue;
        int area = 0;
        while (k < 2 * n) {
            // cout << Disline(p[i], p[k], p1) << endl;
            area += Area(p[i], p[k], p[k - 1]);
            if (!cmp(p[i], p[k + 1], p1, r1)) break;
            if (Cross(p[i] - p[k], p[i] - p1) * Cross(p[i] - p[k + 1], p[i] - p1) > 0) break;
            k ++;
        }
        ans = max(ans, area);
    }
    writeln(ans);
}

int main() {
    int T = 1; read(T);
    while (T--) solve();
    // system("pause");
    return 0;
}