#if __INCLUDE_LEVEL__ == 0

#include __BASE_FILE__

using P = kactl::Point<int64_t>;

void Solve() {
  int n;
  IN(n);
  P center;
  int64_t radius;
  IN(center.x, center.y, radius);
  vector<P> p(2 * n);
  for (int i : Rep(0, n)) {
    IN(p[i].x, p[i].y);
    p[n + i] = p[i];
  }

  auto Check = [&](int i, int j) -> bool {
    if ((p[j] - p[i]).cross(center - p[i]) < 0) {
      return false;
    }
    return (p[j] - p[i]).cross(center - p[i]) >= sqrtl((p[j] - p[i]).dist2()) * radius;
  };

  int64_t ans = -INF64;
  int64_t sum = 0;
  int j = 0;
  for (int i : Rep(0, n)) {
    while (Check(i, j + 1)) {
      sum += p[j].cross(p[j + 1]);
      ++j;
    }
    int64_t cur = p[j].cross(p[i]) + sum;
    // for (int k : Rep(i, j)) {
    //   cur += p[k].cross(p[k + 1]);
    // }
    SetMax(ans, cur);
    sum -= p[i].cross(p[i + 1]);
  }
  OUT(ans);
}

int main() {
  ios::sync_with_stdio(false);
  cin.tie(nullptr);

  int t;
  IN(t);
  while (t--) {
    Solve();
  }
}

#elif __INCLUDE_LEVEL__ == 1

#include <bits/stdc++.h>

template <class T> concept Range = std::ranges::range<T> && !std::convertible_to<T, std::string_view>;
template <class T> concept Tuple = std::__is_tuple_like<T>::value && !Range<T>;

namespace std {

istream& operator>>(istream& is, Range auto&& r) {
  for (auto&& e : r) is >> e;
  return is;
}
istream& operator>>(istream& is, Tuple auto&& t) {
  apply([&](auto&... xs) { (is >> ... >> xs); }, t);
  return is;
}

ostream& operator<<(ostream& os, Range auto&& r) {
  auto sep = "";
  for (auto&& e : r) os << exchange(sep, " ") << e;
  return os;
}
ostream& operator<<(ostream& os, Tuple auto&& t) {
  auto sep = "";
  apply([&](auto&... xs) { ((os << exchange(sep, " ") << xs), ...); }, t);
  return os;
}

}  // namespace std

using namespace std;

// https://github.com/kth-competitive-programming/kactl
namespace kactl {

typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;

template <class T> int sgn(T x) { return (x > 0) - (x < 0); }
template <class T>
struct Point {
  typedef Point P;
  T x, y;
  explicit Point(T x = 0, T y = 0) : x(x), y(y) {}
  bool operator<(P p) const { return tie(x, y) < tie(p.x, p.y); }
  bool operator==(P p) const { return tie(x, y) == tie(p.x, p.y); }
  P operator+(P p) const { return P(x + p.x, y + p.y); }
  P operator-(P p) const { return P(x - p.x, y - p.y); }
  P operator*(T d) const { return P(x * d, y * d); }
  P operator/(T d) const { return P(x / d, y / d); }
  T dot(P p) const { return x * p.x + y * p.y; }
  T cross(P p) const { return x * p.y - y * p.x; }
  T cross(P a, P b) const { return (a - *this).cross(b - *this); }
  T dist2() const { return x * x + y * y; }
  double dist() const { return sqrt((double)dist2()); }
  double angle() const { return atan2(y, x); }
  P unit() const { return *this / dist(); }
  P perp() const { return P(-y, x); }
  P normal() const { return perp().unit(); }
  P rotate(double a) const {
    return P(x * cos(a) - y * sin(a), x * sin(a) + y * cos(a));
  }
  friend ostream& operator<<(ostream& os, P p) {
    return os << "(" << p.x << "," << p.y << ")";
  }
};

}  // namespace kactl

#define LAMBDA2(x, y, ...) [&](auto&& x, auto&& y) -> decltype(auto) { return __VA_ARGS__; }
#define Rep(...) [](int l, int r) { return views::iota(min(l, r), r); }(__VA_ARGS__)
#define SetMax(...) LAMBDA2(x, y, x < y && (x = y, 1))(__VA_ARGS__)
#define INF64 (INT64_MAX / 2)
#define IN(...) cin >> forward_as_tuple(__VA_ARGS__)
#define OUT(...) cout << forward_as_tuple(__VA_ARGS__) << '\n'

#endif  // __INCLUDE_LEVEL__ == 1