#include <bits/stdc++.h>
using namespace std;
using LL = long long;
using point_t = long double; //全局数据类型，可修改为 long long 等

const point_t eps = 1e-10;
const long double PI = acosl(-1);
//const long double PI = numbers::pi_v<long double>;

// 点与向量
template <typename T>
struct point{
    T x, y;

    bool operator==(const point &a) const { return (abs(x - a.x) <= eps && abs(y - a.y) <= eps); }
    bool operator<(const point &a) const{
        if (abs(x - a.x) <= eps)
            return y < a.y - eps;
        return x < a.x - eps;
    }
    bool operator>(const point &a) const { return !(*this < a || *this == a); }
    point operator+(const point &a) const { return {x + a.x, y + a.y}; }
    point operator-(const point &a) const { return {x - a.x, y - a.y}; }
    point operator-() const { return {-x, -y}; }
    point operator*(const T k) const { return {k * x, k * y}; }
    point operator/(const T k) const { return {x / k, y / k}; }
    T operator*(const point &a) const { return x * a.x + y * a.y; } // 点积
    T operator^(const point &a) const { return x * a.y - y * a.x; } // 叉积，注意优先级
    int toleft(const point &a) const
    {
        const auto t = (*this) ^ a;
        return (t > eps) - (t < -eps);
    }                                                             // to-left 测试
    T len2() const { return (*this) * (*this); }                  // 向量长度的平方
    T dis2(const point &a) const { return (a - (*this)).len2(); } // 两点距离的平方

    // 涉及浮点数
    long double len() const { return sqrtl(len2()); }                                                                      // 向量长度
    long double dis(const point &a) const { return sqrtl(dis2(a)); }                                                       // 两点距离
    long double ang(const point &a) const { return acosl(max(-1.0l, min(1.0l, ((*this) * a) / (len() * a.len())))); }      // 向量夹角
    point rot(const long double rad) const { return {x * cosl(rad) - y * sinl(rad), x * sinl(rad) + y * cosl(rad)}; }          // 逆时针旋转（给定角度）
    point rot(const long double cosr, const long double sinr) const { return {x * cosr - y * sinr, x * sinr + y * cosr}; } // 逆时针旋转（给定角度的正弦与余弦）
};

using Point = point<point_t>;

// 极角排序
struct argcmp
{
    bool operator()(const Point &a, const Point &b) const
    {
        const auto quad = [](const Point &a)
        {
            if (a.y < -eps)
                return 1;
            if (a.y > eps)
                return 4;
            if (a.x < -eps)
                return 5;
            if (a.x > eps)
                return 3;
            return 2;
        };
        const int qa = quad(a), qb = quad(b);
        if (qa != qb)
            return qa < qb;
        const auto t = a ^ b;
        // if (abs(t)<=eps) return a*a<b*b-eps;  // 不同长度的向量需要分开
        return t > eps;
    }
};

// 直线
template <typename T>
struct line
{
    point<T> p, v; // p 为直线上一点，v 为方向向量

    bool operator==(const line &a) const { return v.toleft(a.v) == 0 && v.toleft(p - a.p) == 0; }
    int toleft(const point<T> &a) const { return v.toleft(a - p); } // to-left 测试
    bool operator<(const line &a) const                             // 半平面交算法定义的排序
    {
        if (abs(v ^ a.v) <= eps && v * a.v >= -eps)
            return toleft(a.p) == -1;
        return argcmp()(v, a.v);
    }

    // 涉及浮点数
    point<T> inter(const line &a) const { return p + v * ((a.v ^ (p - a.p)) / (v ^ a.v)); } // 直线交点
    long double dis(const point<T> &a) const { return abs(v ^ (a - p)) / v.len(); }         // 点到直线距离
    point<T> proj(const point<T> &a) const { return p + v * ((v * (a - p)) / (v * v)); }    // 点在直线上的投影
    point<T> symmetry(const point<T> &a) const { return proj(a) * 2 - a;}                    // 点关于直线的对称点 
};

using Line = line<point_t>;

//线段
template <typename T>
struct segment
{
    point<T> a, b;

    bool operator<(const segment &s) const { return make_pair(a, b) < make_pair(s.a, s.b); }

    // 判定性函数建议在整数域使用

    // 判断点是否在线段上
    // -1 点在线段端点 | 0 点不在线段上 | 1 点严格在线段上
    int is_on(const point<T> &p) const
    {
        if (p == a || p == b)
            return -1;
        return (p - a).toleft(p - b) == 0 && (p - a) * (p - b) < -eps;
    }

    // 判断线段直线是否相交
    // -1 直线经过线段端点 | 0 线段和直线不相交 | 1 线段和直线严格相交
    int is_inter(const line<T> &l) const
    {
        if (l.toleft(a) == 0 || l.toleft(b) == 0)
            return -1;
        return l.toleft(a) != l.toleft(b);
    }

    // 判断两线段是否相交
    // -1 在某一线段端点处相交 | 0 两线段不相交 | 1 两线段严格相交
    int is_inter(const segment<T> &s) const
    {
        if (is_on(s.a) || is_on(s.b) || s.is_on(a) || s.is_on(b))
            return -1;
        const line<T> l{a, b - a}, ls{s.a, s.b - s.a};
        return l.toleft(s.a) * l.toleft(s.b) == -1 && ls.toleft(a) * ls.toleft(b) == -1;
    }

    // 点到线段距离
    long double dis(const point<T> &p) const
    {
        if ((p - a) * (b - a) < -eps || (p - b) * (a - b) < -eps)
            return min(p.dis(a), p.dis(b));
        const line<T> l{a, b - a};
        return l.dis(p);
    }

    // 两线段间距离
    long double dis(const segment<T> &s) const
    {
        if (is_inter(s))
            return 0;
        return min({dis(s.a), dis(s.b), s.dis(a), s.dis(b)});
    }

    // 只求整点交点可以不使用浮点数,避免精度问题,使用前需要先判断是否有交点 
    pair<bool, point<T> > int_inter(const segment &s){

        // 线段转为直线的一般式
        auto seg2line = [&](const segment &s){
            T A = s.a.y - s.b.y;
            T B = s.b.x - s.a.x;
            T C = -A * s.a.x - B * s.a.y;
            return array{A, B, C};
        };

        auto [A1, B1, C1] = seg2line(*this);
        auto [A2, B2, C2] = seg2line(s);
        T dx = C1 * B2 - C2 * B1;
        T dy = A1 * C2 - A2 * C1;
        T d = B1 * A2 - B2 * A1;
        if (d == 0) return {false, {}};
        if (dy % d || dx % d) return {false, {}};
        return {true, {dx / d, dy / d}};
    }

};
using Segment = segment<point_t>;

// 多边形
template <typename T>
struct polygon
{
    vector<point<T>> p; // 以逆时针顺序存储

    size_t nxt(const size_t i) const { return i == p.size() - 1 ? 0 : i + 1; }
    size_t pre(const size_t i) const { return i == 0 ? p.size() - 1 : i - 1; }

    // 回转数
    // 返回值第一项表示点是否在多边形边上
    // 对于狭义多边形，回转数为 0 表示点在多边形外，否则点在多边形内
    pair<bool, int> winding(const point<T> &a) const
    {
        int cnt = 0;
        for (size_t i = 0; i < p.size(); i++)
        {
            const point<T> u = p[i], v = p[nxt(i)];
            if (abs((a - u) ^ (a - v)) <= eps && (a - u) * (a - v) <= eps)
                return {true, 0};
            if (abs(u.y - v.y) <= eps)
                continue;
            const Line uv = {u, v - u};
            if (u.y < v.y - eps && uv.toleft(a) <= 0)
                continue;
            if (u.y > v.y + eps && uv.toleft(a) >= 0)
                continue;
            if (u.y < a.y - eps && v.y >= a.y - eps)
                cnt++;
            if (u.y >= a.y - eps && v.y < a.y - eps)
                cnt--;
        }
        return {false, cnt};
    }

    // 射线法 2表示在多边形内,1表示在多边形上,0表示在多边形外
    int is_in(const point<T> &a){
        int x = 0;
        for(size_t i = 0; i < p.size(); i++){
            segment<T> s = {p[i], p[nxt(i)]};
            if (s.is_on(a)) return 1;
            point<T> p1 = p[i] - a, p2 = p[nxt(i)] - a;
            if(p1.y > p2.y) swap(p1, p2);
            if(p1.y < eps && p2.y > eps && (p1 ^ p2) > eps) x = !x;
        }
        return x ? 2 : 0;
    }

    // 多边形面积的两倍
    // 可用于判断点的存储顺序是顺时针或逆时针
    T area() const
    {
        T sum = 0;
        for (size_t i = 0; i < p.size(); i++)
            sum += p[i] ^ p[nxt(i)];
        return sum;
    }

    // 多边形的周长
    long double circ() const
    {
        long double sum = 0;
        for (size_t i = 0; i < p.size(); i++)
            sum += p[i].dis(p[nxt(i)]);
        return sum;
    }
};

using Polygon = polygon<point_t>;

//凸多边形
template <typename T>
struct convex : polygon<T>
{
    // 闵可夫斯基和
    convex operator+(const convex &c) const
    {
        const auto &p = this->p;
        vector<Segment> e1(p.size()), e2(c.p.size()), edge(p.size() + c.p.size());
        vector<point<T>> res;
        res.reserve(p.size() + c.p.size());
        const auto cmp = [](const Segment &u, const Segment &v)
        { return argcmp()(u.b - u.a, v.b - v.a); };
        for (size_t i = 0; i < p.size(); i++)
            e1[i] = {p[i], p[this->nxt(i)]};
        for (size_t i = 0; i < c.p.size(); i++)
            e2[i] = {c.p[i], c.p[c.nxt(i)]};
        rotate(e1.begin(), min_element(e1.begin(), e1.end(), cmp), e1.end());
        rotate(e2.begin(), min_element(e2.begin(), e2.end(), cmp), e2.end());
        merge(e1.begin(), e1.end(), e2.begin(), e2.end(), edge.begin(), cmp);
        const auto check = [](const vector<point<T>> &res, const point<T> &u)
        {
            const auto back1 = res.back(), back2 = *prev(res.end(), 2);
            return (back1 - back2).toleft(u - back1) == 0 && (back1 - back2) * (u - back1) >= -eps;
        };
        auto u = e1[0].a + e2[0].a;
        for (const auto &v : edge)
        {
            while (res.size() > 1 && check(res, u))
                res.pop_back();
            res.push_back(u);
            u = u + v.b - v.a;
        }
        if (res.size() > 1 && check(res, res[0]))
            res.pop_back();
        return {res};
    }

    // 旋转卡壳
    // func 为更新答案的函数，可以根据题目调整位置
    template <typename F>
    void rotcaliper(const F &func) const
    {
        const auto &p = this->p;
        const auto area = [](const point<T> &u, const point<T> &v, const point<T> &w)
        { return (w - u) ^ (w - v); };
        for (size_t i = 0, j = 1; i < p.size(); i++)
        {
            const auto nxti = this->nxt(i);
            func(p[i], p[nxti], p[j]);
            while (area(p[this->nxt(j)], p[i], p[nxti]) >= area(p[j], p[i], p[nxti]))
            {
                j = this->nxt(j);
                func(p[i], p[nxti], p[j]);
            }
        }
    }

    // 凸多边形的直径的平方
    T diameter2() const
    {
        const auto &p = this->p;
        if (p.size() == 1)
            return 0;
        if (p.size() == 2)
            return p[0].dis2(p[1]);
        T ans = 0;
        auto func = [&](const point<T> &u, const point<T> &v, const point<T> &w)
        { ans = max({ans, w.dis2(u), w.dis2(v)}); };
        rotcaliper(func);
        return ans;
    }

    // 判断点是否在凸多边形内
    // 复杂度 O(logn)
    // -1 点在多边形边上 | 0 点在多边形外 | 1 点在多边形内
    int is_in(const point<T> &a) const
    {
        const auto &p = this->p;
        if (p.size() == 1)
            return a == p[0] ? -1 : 0;
        if (p.size() == 2)
            return segment<T>{p[0], p[1]}.is_on(a) ? -1 : 0;
        if (a == p[0])
            return -1;
        if ((p[1] - p[0]).toleft(a - p[0]) == -1 || (p.back() - p[0]).toleft(a - p[0]) == 1)
            return 0;
        const auto cmp = [&](const Point &u, const Point &v)
        { return (u - p[0]).toleft(v - p[0]) == 1; };
        const size_t i = lower_bound(p.begin() + 1, p.end(), a, cmp) - p.begin();
        if (i == 1)
            return segment<T>{p[0], p[i]}.is_on(a) ? -1 : 0;
        if (i == p.size() - 1 && segment<T>{p[0], p[i]}.is_on(a))
            return -1;
        if (segment<T>{p[i - 1], p[i]}.is_on(a))
            return -1;
        return (p[i] - p[i - 1]).toleft(a - p[i - 1]) > 0;
    }

    // 凸多边形关于某一方向的极点
    // 复杂度 O(logn)
    // 参考资料：https://codeforces.com/blog/entry/48868
    template <typename F>
    size_t extreme(const F &dir) const
    {
        const auto &p = this->p;
        const auto check = [&](const size_t i)
        { return dir(p[i]).toleft(p[this->nxt(i)] - p[i]) >= 0; };
        const auto dir0 = dir(p[0]);
        const auto check0 = check(0);
        if (!check0 && check(p.size() - 1))
            return 0;
        const auto cmp = [&](const Point &v)
        {
            const size_t vi = &v - p.data();
            if (vi == 0)
                return 1;
            const auto checkv = check(vi);
            const auto t = dir0.toleft(v - p[0]);
            if (vi == 1 && checkv == check0 && t == 0)
                return 1;
            return checkv ^ (checkv == check0 && t <= 0);
        };
        return partition_point(p.begin(), p.end(), cmp) - p.begin();
    }

    // 过凸多边形外一点求凸多边形的切线，返回切点下标
    // 复杂度 O(logn)
    // 必须保证点在多边形外
    pair<size_t, size_t> tangent(const point<T> &a) const
    {
        const size_t i = extreme([&](const point<T> &u)
                                 { return u - a; });
        const size_t j = extreme([&](const point<T> &u)
                                 { return a - u; });
        return {i, j};
    }

    // 求平行于给定直线的凸多边形的切线，返回切点下标
    // 复杂度 O(logn)
    pair<size_t, size_t> tangent(const line<T> &a) const
    {
        const size_t i = extreme([&](...)
                                 { return a.v; });
        const size_t j = extreme([&](...)
                                 { return -a.v; });
        return {i, j};
    }
};

using Convex = convex<point_t>;

// 整数圆
// struct Circle{
//     Point c;
//     LL r;

//     bool operator==(const Circle &a) const { return c == a.c && r == a.r; }

//     // 点与圆的关系
//     // -1 圆上 | 0 圆外 | 1 圆内
//     int is_in(const Point &p) const
//     {
//         if (is_integral<point_t>::value)
//         {
//             long long v1 = p.dis2(c);
//             long long v2 = 1LL * r * r;
//             if (v1 == v2) return -1;
//             if (v1 > v2) return 0;
//             return 1;
//         }
//         const long double d = p.dis(c);
//         return abs(d - r) <= eps ? -1 : d < r - eps;
//     }

//     // 直线与圆关系
//     // 0 相离 | 1 相切 | 2 相交
//     int relation(const line<point_t> &l) const
//     {
//         if (is_integral<point_t>::value)
//         {
//             Point p1 = l.p, p2 = l.p + l.v;
//             long long w2 = p1.dis2(p2);
//             long long area = abs((p1 - p2) ^ (p1 - c));
//             __int128_t v1 = __int128_t(area) * area;
//             __int128_t v2 = __int128_t(r) * r * w2;
//             if (v1 == v2) return 1;
//             if (v1 > v2) return 0;
//             return 2;
//         }
//         const long double d = l.dis(c);
//         if (d > r + eps)
//             return 0;
//         if (abs(d - r) <= eps)
//             return 1;
//         return 2;
//     }

//     // 圆与圆关系
//     // -1 相同 | 0 相离 | 1 外切 | 2 相交 | 3 内切 | 4 内含
//     int relation(const Circle &a) const
//     {
//         if (*this == a)
//             return -1;
//         if (is_integral<point_t>::value)
//         {
//             long long d2 = c.dis2(a.c);
//             long long sr2 = 1LL * (r + a.r) * (r + a.r);
//             if (d2 > sr2) return 0;
//             if (d2 == sr2) return 1;
//             long long dr2 = 1LL * (r - a.r) * (r - a.r);
//             if (d2 == dr2) return 3;
//             if (d2 < dr2) return 4;
//             return 2;
//         }
//         const long double d = c.dis(a.c);
//         if (d > r + a.r + eps)
//             return 0;
//         if (abs(d - r - a.r) <= eps)
//             return 1;
//         if (abs(d - abs(r - a.r)) <= eps)
//             return 3;
//         if (d < abs(r - a.r) - eps)
//             return 4;
//         return 2;
//     }

//     // 待补充: 线段与圆是否相交,线段与圆的交点数量.

//     int inters(const segment<point_t> &s){
//         if (s.a == s.b){
//             return int(is_in(s.a) == -1);
//         }
//         auto p1 = s.a, p2 = s.b;
        
//         long long r2 = (long long)r * r;
//         long long d1 = p1.dis2(c);
//         long long d2 = p2.dis2(c);
//         long long t1 = (c - p1) * (p2 - p1);
//         long long t2 = (c - p2) * (p1 - p2);
        
//         long long w2 = p1.dis2(p2);
//         long long area = abs((p1 - c) ^ (p2 - c));
//         // area2 / h2, r2

//         __int128_t v1 = __int128_t(area) * area;
//         __int128_t v2 = __int128_t(w2) * r2;

//         auto cmp = [&](long long a, long long b){
//             if (a > b) return 1;
//             if (a < b) return -1;
//             return 0;
//         };

//         int ans = 0;
//         // 直线与圆相交
//         if (v1 < v2){
//             if (d1 < r2 && d2 < r2){
//                 ans += 0;
//             }
//             else if (d1 == r2 && d2 == r2){
//                 ans += 2;
//             }
//             else if (cmp(d1, r2) * cmp(d2, r2) == -1){
//                 ans += 1;
//             }
//             else if (d1 == r2){
//                 if (d2 > r2 && t1 > 0) ans += 2;
//                 else ans += 1;
//             }
//             else if (d2 == r2){
//                 if (d1 > r2 && t2 > 0) ans += 2;
//                 else ans += 1;
//             }
//             else{
//                 if (t1 > 0 && t2 > 0){
//                     ans += 2;
//                 }
//             }
//         }
//         // 直线与圆相切
//         else if (v1 == v2){
//             if (t1 >= 0 && t2 >= 0){
//                 ans += 1;
//             }
//         }
//         return ans;
//     }

// };

// 圆
struct Circle
{
    Point c;
    long double r;

    bool operator==(const Circle &a) const { return c == a.c && abs(r - a.r) <= eps; }
    long double circ() const { return 2 * PI * r; } // 周长
    long double area() const { return PI * r * r; } // 面积

    // 点与圆的关系
    // -1 圆上 | 0 圆外 | 1 圆内
    int is_in(const Point &p) const
    {
        const long double d = p.dis(c);
        return abs(d - r) <= eps ? -1 : d < r - eps;
    }

    // 直线与圆关系
    // 0 相离 | 1 相切 | 2 相交
    int relation(const Line &l) const
    {
        const long double d = l.dis(c);
        if (d > r + eps)
            return 0;
        if (abs(d - r) <= eps)
            return 1;
        return 2;
    }

    // 圆与圆关系
    // -1 相同 | 0 相离 | 1 外切 | 2 相交 | 3 内切 | 4 内含
    int relation(const Circle &a) const
    {
        if (*this == a)
            return -1;
        const long double d = c.dis(a.c);
        if (d > r + a.r + eps)
            return 0;
        if (abs(d - r - a.r) <= eps)
            return 1;
        if (abs(d - abs(r - a.r)) <= eps)
            return 3;
        if (d < abs(r - a.r) - eps)
            return 4;
        return 2;
    }

    // 直线与圆的交点
    vector<Point> inter(const Line &l) const
    {
        const long double d = l.dis(c);
        const Point p = l.proj(c);
        const int t = relation(l);
        if (t == 0)
            return vector<Point>();
        if (t == 1)
            return vector<Point>{p};
        const long double k = sqrt(r * r - d * d);
        return vector<Point>{p - (l.v / l.v.len()) * k, p + (l.v / l.v.len()) * k};
    }

    // 圆与圆交点
    vector<Point> inter(const Circle &a) const
    {
        const long double d = c.dis(a.c);
        const int t = relation(a);
        if (t == -1 || t == 0 || t == 4)
            return vector<Point>();
        Point e = a.c - c;
        e = e / e.len() * r;
        if (t == 1 || t == 3)
        {
            if (r * r + d * d - a.r * a.r >= -eps)
                return vector<Point>{c + e};
            return vector<Point>{c - e};
        }
        const long double costh = (r * r + d * d - a.r * a.r) / (2 * r * d), sinth = sqrt(1 - costh * costh);
        return vector<Point>{c + e.rot(costh, -sinth), c + e.rot(costh, sinth)};
    }

    // 圆与圆交面积
    long double inter_area(const Circle &a) const
    {
        const long double d = c.dis(a.c);
        const int t = relation(a);
        if (t == -1)
            return area();
        if (t < 2)
            return 0;
        if (t > 2)
            return min(area(), a.area());
        const long double costh1 = (r * r + d * d - a.r * a.r) / (2 * r * d), costh2 = (a.r * a.r + d * d - r * r) / (2 * a.r * d);
        const long double sinth1 = sqrt(1 - costh1 * costh1), sinth2 = sqrt(1 - costh2 * costh2);
        const long double th1 = acos(costh1), th2 = acos(costh2);
        return r * r * (th1 - costh1 * sinth1) + a.r * a.r * (th2 - costh2 * sinth2);
    }

    // 过圆外一点圆的切线
    vector<Line> tangent(const Point &a) const
    {
        const int t = is_in(a);
        if (t == 1)
            return vector<Line>();
        if (t == -1)
        {
            const Point v = {-(a - c).y, (a - c).x};
            return vector<Line>{{a, v}};
        }
        Point e = a - c;
        e = e / e.len() * r;
        const long double costh = r / c.dis(a), sinth = sqrt(1 - costh * costh);
        const Point t1 = c + e.rot(costh, -sinth), t2 = c + e.rot(costh, sinth);
        return vector<Line>{{a, t1 - a}, {a, t2 - a}};
    }

    // 两圆的公切线
    vector<Line> tangent(const Circle &a) const
    {
        const int t = relation(a);
        vector<Line> lines;
        if (t == -1 || t == 4)
            return lines;
        if (t == 1 || t == 3)
        {
            const Point p = inter(a)[0], v = {-(a.c - c).y, (a.c - c).x};
            lines.push_back({p, v});
        }
        const long double d = c.dis(a.c);
        const Point e = (a.c - c) / (a.c - c).len();
        if (t <= 2)
        {
            const long double costh = (r - a.r) / d, sinth = sqrt(1 - costh * costh);
            const Point d1 = e.rot(costh, -sinth), d2 = e.rot(costh, sinth);
            const Point u1 = c + d1 * r, u2 = c + d2 * r, v1 = a.c + d1 * a.r, v2 = a.c + d2 * a.r;
            lines.push_back({u1, v1 - u1});
            lines.push_back({u2, v2 - u2});
        }
        if (t == 0)
        {
            const long double costh = (r + a.r) / d, sinth = sqrt(1 - costh * costh);
            const Point d1 = e.rot(costh, -sinth), d2 = e.rot(costh, sinth);
            const Point u1 = c + d1 * r, u2 = c + d2 * r, v1 = a.c - d1 * a.r, v2 = a.c - d2 * a.r;
            lines.push_back({u1, v1 - u1});
            lines.push_back({u2, v2 - u2});
        }
        return lines;
    }

    // 圆的反演
    tuple<int, Circle, Line> inverse(const Line &l) const
    {
        const Circle null_c = {{0.0, 0.0}, 0.0};
        const Line null_l = {{0.0, 0.0}, {0.0, 0.0}};
        if (l.toleft(c) == 0)
            return {2, null_c, l};
        const Point v = l.toleft(c) == 1 ? Point{l.v.y, -l.v.x} : Point{-l.v.y, l.v.x};
        const long double d = r * r / l.dis(c);
        const Point p = c + v / v.len() * d;
        return {1, {(c + p) / 2, d / 2}, null_l};
    }

    tuple<int, Circle, Line> inverse(const Circle &a) const
    {
        const Circle null_c = {{0.0, 0.0}, 0.0};
        const Line null_l = {{0.0, 0.0}, {0.0, 0.0}};
        const Point v = a.c - c;
        if (a.is_in(c) == -1)
        {
            const long double d = r * r / (a.r + a.r);
            const Point p = c + v / v.len() * d;
            return {2, null_c, {p, {-v.y, v.x}}};
        }
        if (c == a.c)
            return {1, {c, r * r / a.r}, null_l};
        const long double d1 = r * r / (c.dis(a.c) - a.r), d2 = r * r / (c.dis(a.c) + a.r);
        const Point p = c + v / v.len() * d1, q = c + v / v.len() * d2;
        return {1, {(p + q) / 2, p.dis(q) / 2}, null_l};
    }
};
int main(){

#ifdef LOCAL
    freopen("data.in", "r", stdin);
    freopen("data.out", "w", stdout);
#endif

    cin.tie(0);
    cout.tie(0);
    ios::sync_with_stdio(0);

    int T;
    cin >> T;
    while(T--){
        int n;
        cin >> n;
        Circle c;
        {
            int x, y, r;
            cin >> x >> y >> r;
            c = {{1.0L * x, 1.0L * y}, 1.0L * r};
        }

        auto cross = [&](pair<LL, LL> a, pair<LL, LL> b){
            auto [x1, y1] = a;
            auto [x2, y2] = b;
            return x1 * y2 - y1 * x2;
        };

        vector<pair<LL, LL> > pt(n * 2);
        vector<Point> p(2 * n);
        vector<__int128_t> sum(2 * n);
        for(int i = 0; i < n; i++){
            int x, y;
            cin >> x >> y;
            pt[i] = pt[i + n] = {x, y};
            p[i] = {1.0L * x, 1.0L * y};
            p[i + n] = p[i];
        }
        for(int i = 1; i < 2 * n; i++){
            sum[i] = cross(pt[i - 1], pt[i]);
            sum[i] += sum[i - 1];
        }
        __int128_t ans = 0;
        for(int i = 0; i < n; i++){
            auto v = c.tangent(p[i]);
            if (v.size() != 2){
                continue;
            }
            // assert(v.size() == 2);
            auto l1 = v[0], l2 = v[1];
            if ((l1.v ^ l2.v) < -eps) swap(l1, l2);
            {
                int l = i, r = i + n - 1;
                while(l < r){
                    int mid = (l + r + 1) / 2;
                    if (((p[mid] - p[i]) ^ l1.v) > -eps){
                        l = mid;
                    }
                    else{
                        r = mid - 1;
                    }
                }
                if (r > i + 1) ans = max(ans, sum[r] - sum[i] + cross(pt[r], pt[i]));
            }
            {
                int l = i + 1, r = i + n;
                while(l < r){
                    int mid = (l + r) / 2;
                    if ((l2.v ^ (p[mid] - p[i])) > -eps){
                        r = mid;
                    }
                    else{
                        l = mid + 1;
                    }
                }
                if (l < i + n - 1) ans = max(ans, sum[i + n] - sum[l] + cross(pt[i + n], pt[l]));
            }
        }
        cout << (LL)ans << '\n';
    }

}