#include <bits/stdc++.h>

using namespace std;

#define F(i, a, b) for (int i = a; i < b; i++)
#define ALL(x) x.begin(), x.end()
#define IOS ios_base::sync_with_stdio(0)

typedef vector<int> vi;
typedef vector<vector<int>> vvi;
typedef pair<int, int> ii;
typedef vector<ii> vii;
typedef long long ll;

struct point {
  ll x, y;
};

bool isValid(point &p1, point &p2, bool shouldBeNegative, ll radius) {
  double a, b, c;
  if (p1.x == p2.x) {
    a = -1, b = 0, c = p1.x;
  } else {
    a = (double)(p2.y - p1.y) / (p2.x - p1.x);
    b = -1;
    c = (double)(p1.y * p2.x - p2.y * p1.x) / (p2.x - p1.x);
  }
  double dSq = c * c / (a * a + b * b), x = -(a * c) / (a * a + b * b),
         y = -(b * c) / (a * a + b * b);
  double norm = sqrt(x * x + y * y);
  x /= norm, y /= norm;
  double x2 = p2.x - p1.x, y2 = p2.y - p1.y;
  bool negative = (x * y2 - x2 * y < 0);

  return negative == shouldBeNegative && dSq >= radius * radius;
}

ll solve(vector<point> &points, bool shouldBeNegative, ll radius) {
  int n = points.size();
  vector<ll> ps(n + 1);
  F(i, 0, n) {
    ps[i + 1] = ps[i] + points[i].x * points[(i + 1) % n].y -
                points[i].y * points[(i + 1) % n].x;
  }
  ll ans = 0;

  F(i, 0, n) {
    int l = 2, right = n - 1;
    while (l < right) {
      int mid = (l + right) / 2;
      // cout << i << ' ' << mid << ' ' << l << ' ' << right << endl;
      if (!isValid(points[i], points[(mid + i) % n], shouldBeNegative,
                   radius)) {
        right = mid;
      } else {
        l = mid + 1;
      }
    }

    l = (i + l) % n;
    if (!isValid(points[i], points[l], shouldBeNegative, radius)) {
      l = (l + n - 1) % n;
    }

    ll tmp =
        ps[l] - ps[i] + points[l].x * points[i].y - points[l].y * points[i].x;
    if (l < i) {
      tmp = ps[n] + tmp;
    }
    // cout << i << ' ' << l << ' ' << tmp << endl;
    ans = max(ans, tmp);
  }

  return ans;
}

int main() {
  int t, n;
  cin >> t;

  while (t--) {
    cin >> n;

    ll xc, yc, radius;
    cin >> xc >> yc >> radius;
    vector<point> points(n);
    point center;
    center.x = center.y = 0;

    F(i, 0, n) {
      cin >> points[i].x >> points[i].y;
      points[i].x -= xc, points[i].y -= yc;
    }

    ll ans = solve(points, false, radius);
    reverse(ALL(points));
    // ans = max(ans, solve(points, false, radius));
    cout << ans << '\n';
  }
}