#include <iostream>
#include <queue>
#include <set>
#include <stack>
#include <utility>
#include <tuple>
#include <iomanip>
#include <map>
#include <algorithm>
#include <math.h>
#include <string>
#include <vector>
#include <unordered_map>
#define ll long long
#define inf 10000000000007
#define mod 1000000007

using namespace std;

const int BLOCK = 450;


ll fastpow(ll n, ll x) {

	if (x == 0) {
		return 1;
	}
	else {
		ll ret = fastpow(n, x / 2);
		ret = ((ret % mod) * (ret % mod)) % mod;
		if (x % 2 == 0) {
			return ret;
		}
		else {
			return ((ret) * (n)) % mod;
		}
	}
}


ll gcd(ll a, ll b) {
	if (a == 0) {
		return b;
	}
	if (b == 0) {
		return a;
	}
	else {
		return gcd(b, a % b);
	}
}
ll lcm(ll a, ll b) {
	ll val = (a % mod * b % mod) % mod;
	val = (val * fastpow(gcd(a, b), mod - 2)) % mod;
	return val;
}
int Logk(ll n, ll k) {
	if (k == 1) {
		return 1;
	}
	if (n == 0) {
		return 0;
	}
	int count = -1;
	while (n > 0) {
		count++;
		n /= k;
	}
	return count;
}
struct Dsu {
	vector<int> par;

	void init(int n) {
		par.resize(n + 5, 0);
		for (int i = 1; i <= n; i++) par[i] = i;
	}

	int find(int u) {
		if (par[u] == u) return u;
		return par[u] = find(par[u]);
	}

	bool join(int u, int v) {
		u = find(u); v = find(v);
		if (u == v) return false;
		par[v] = u;
		return true;
	}
} dsu;
struct point {
	ll x, y;
};
struct line {
	ll a, b, c;
};
struct vecto {
	ll x, y;
};
line create(point point1, point point2) {
	line ret;
	ret.a = point2.y - point1.y;
	ret.b = point1.x - point2.x;
	ret.c = -(ret.a * point1.x + ret.b * point1.y);
	return ret;
}
pair<ll, ll> dif(line line1, point point1) {
	ll tu = abs(line1.a * point1.x + line1.b * point1.y + line1.c);
	tu *= tu;
	ll mau = line1.a * line1.a + line1.b * line1.b;
	return { tu, mau };
}
int locate(point A, point B, point C) {
	vecto AB = { B.x - A.x, B.y - A.y };
	vecto AC = { C.x - A.x, C.y - A.y };
	if (AB.x * AC.y - AB.y * AC.x < 0) {
		return 2;
		//RIGHT
	}
	else if (AB.x * AC.y - AB.y * AC.x > 0) {
		return 1;
	}
	else {
		return 0;
	}
}
void solve() {
	int n;
	cin >> n;
	ll x, y, r;
	cin >> x >> y >> r;
	vector<point> a;
	vector<ll> prefix(n+1);
	vector<ll> res(n, -1);
	
	for (int i = 0; i < n; i++) {
		ll x, y;
		cin >> x >> y;
		a.push_back({ x, y });
	}
	a.push_back(a[0]);
	prefix[0] = 0;
	for (int i = 1; i <= n; i++) {
		prefix[i] = prefix[i-1] + (a[i-1].x * a[i].y - a[i-1].y * a[i].x);
		
	}
	
	ll ans = 0;
	int cur = 0;
	int nxt = 2;
	int count = 0;
	while (1) {
		count++;
		if (count >= 100000) {
			break;
		}
		point first = a[cur];
		
		res[cur] = 0;
		point last = a[nxt];
		pair<ll, ll> dis = dif(create(first, last), { x, y });
		
		
		if (dis.first <= r * r * dis.second) {
			
			cur++;

			cur %= n;
			if (abs(nxt - cur) <= 1) {
					nxt = cur + 2;
					nxt %= n;
			}
			
			
			
			
		}
		else {
			
			if (first.y <= last.y) {
				
				int type = locate(first, last, { x, y });
				ll ret = 0;
				if (type == 1) {
					
					if (cur < nxt) {
						
						
						ret = prefix[nxt] - prefix[cur] + (a[nxt].x * a[cur].y - a[nxt].y * a[cur].x);
						
					}
					else {
						
						
						ret = prefix[n] - (prefix[cur] - prefix[nxt] + (a[cur].x * a[nxt].y - a[cur].y * a[nxt].x));
						
					}
					ans = max(ans, ret);
					nxt++;
					
					nxt %= n;
					if (abs(nxt - cur) <= 1) {
						
						nxt = cur - 2;
						
					}
					
				}
				else {
					if (cur < nxt) {


						ret = prefix[nxt] - prefix[cur] + (a[nxt].x * a[cur].y - a[nxt].y * a[cur].x);

					}
					else {


						ret = prefix[n] - (prefix[cur] - prefix[nxt] + (a[cur].x * a[nxt].y - a[cur].y * a[nxt].x));

					}
					ans = max(ans, prefix[n] - ret);
					cur++;

					cur %= n;
					if (abs(nxt - cur) <= 1) {
						nxt = cur + 2;
						nxt %= n;
					}
					
					
				}
			}
			else {
				int type = locate(first, last, { x, y });
				ll ret = 0;
				if (type == 1) {
					if (cur < nxt) {

						
						ret = prefix[nxt] - prefix[cur] + (a[nxt].x * a[cur].y - a[nxt].y * a[cur].x);
						

					}
					else {

						
						ret = prefix[n] - (prefix[cur] - prefix[nxt] + (a[cur].x * a[nxt].y - a[cur].y * a[nxt].x));

					}
					ans = max(ans, ret);
					nxt++;
					nxt %= n;
					if (abs(nxt - cur) <= 1) {
						nxt = cur - 2;
						nxt %= n;
					}

				}
				else {
					if (cur < nxt) {


						ret = prefix[nxt] - prefix[cur] + (a[nxt].x * a[cur].y - a[nxt].y * a[cur].x);

					}
					else {


						ret = prefix[n] - (prefix[cur] - prefix[nxt] + (a[cur].x * a[nxt].y - a[cur].y * a[nxt].x));

					}
					ans = max(ans, prefix[n] - ret);
					cur++;

					cur %= n;
					if (abs(nxt - cur) <= 1) {
							nxt = cur + 2;
							nxt %= n;
					}
					
					
				}
			}

		}
	}
	cout << ans << endl;
}



int main() {




	ios_base::sync_with_stdio(false);
	cin.tie(NULL);
	cout.tie(NULL);
	
	int t;
	cin >> t;
	while (t--) {
		solve();
	}






























}