#include<cmath>

 #include<queue>

 #include<vector>

 #include<cstring>

 #include<climits>

 #include<algorithm>

 class HouseProtection {

     private:

         static constexpr int N=,M=;

         static constexpr double pi=M_PI;

         using Point=std::pair<int,int>;

         struct Length {

             double l;

             int u,v;

             bool operator < (const Length &rhs) const {

                 return l<rhs.l;

             }

         };

         struct Edge {

             int from,to,remain,next;

         };

         Point a[N],b[N];

         std::vector<Length> len;

         std::vector<Edge> e;

         int s,t,lev[M],cur[M],h[M];

         double sqr(const double &x) const {

             return x*x;

         }

         double dist(const Point &a,const Point &b) const {

             return sqrt(sqr(a.first-b.first)+sqr(a.second-b.second));

         }

         void add_edge(const int &u,const int &v,const int &w) {

             e.push_back({u,v,w,h[u]});

             h[u]=e.size()-;

         }

         void bfs() {

             memset(lev,-,sizeof lev);

             lev[s]=;

             std::queue<int> q;

             q.push(s);

             while(!q.empty()) {

                 const int &x=q.front();

                 for(register int i=h[x];~i;i=e[i].next) {

                     const int &y=e[i].to,&r=e[i].remain;

                     if(r&&!~lev[y]) {

                         lev[y]=lev[x]+;

                         q.push(y);

                     }

                 }

                 q.pop();

             }

         }

         int dfs(const int &x,const int &flow) {

             if(x==t) return flow;

             for(int &i=cur[x];~i;i=e[i].next) {

                 const int &y=e[i].to;

                 if(e[i].remain&&lev[y]>lev[x]) {

                     if(int d=dfs(y,std::min(flow,e[i].remain))) {

                         e[i].remain-=d;

                         e[i^].remain+=d;

                         return d;

                     }

                 }

             }

             return ;

         }

         int dinic() {

             int maxflow=;

             for(;;) {

                 bfs();

                 if(!~lev[t]) break;

                 memcpy(cur,h,sizeof h);

                 while(int flow=dfs(s,INT_MAX)) {

                     maxflow+=flow;

                 }

             }

             return maxflow;

         }

     public:

         double safetyFactor(const std::vector<int> &possibleXForBlue,const std::vector<int> &possibleYForBlue,const std::vector<int> &possibleXForRed,const std::vector<int> &possibleYForRed,const int &R) {

             memset(h,-,sizeof h);

             const int n=possibleXForBlue.size(),m=possibleXForRed.size();

             for(register int i=;i<n;i++) {

                 a[i]={possibleXForBlue[i],possibleYForBlue[i]};

             }

             for(register int i=;i<m;i++) {

                 b[i]={possibleXForRed[i],possibleYForRed[i]};

             }

             for(register int i=;i<n;i++) {

                 for(register int j=;j<m;j++) {

                     const double dis=dist(a[i],b[j])/;

                     if(dis<R) len.push_back({dis,i,j});

                 }

             }

             len.push_back({(double)R,-,-});

             std::sort(len.begin(),len.end());

             s=n+m,t=n+m+;

             for(int i=;i<n;i++) {

                 add_edge(s,i,);

                 add_edge(i,s,);

             }

             for(int i=;i<m;i++) {

                 add_edge(n+i,t,);

                 add_edge(t,n+i,);

             }

             int match=;

             double ans=;

             for(register auto &e:len) {

                 match+=dinic();

                 ans=std::max(ans,pi*sqr(e.l)*(n+m-match));

                 if(e.l<R) {

                     add_edge(e.u,n+e.v,);

                     add_edge(n+e.v,e.u,);

                 }

             }

             return ans;

         }

 };