//        ——By DD_BOND

 //#include<bits/stdc++.h>

 //#include<unordered_map>

 //#include<unordered_set>

 #include<functional>

 #include<algorithm>

 #include<iostream>

 //#include<ext/rope>

 #include<iomanip>

 #include<climits>

 #include<cstring>

 #include<cstdlib>

 #include<cstddef>

 #include<cstdio>

 #include<memory>

 #include<vector>

 #include<cctype>

 #include<string>

 #include<cmath>

 #include<queue>

 #include<deque>

 #include<ctime>

 #include<stack>

 #include<map>

 #include<set>

 #define fi first

 #define se second

 #define pb push_back

 typedef long long ll;

 using namespace std;

 const int MAXN=1e3+;

 const double eps=1e-;

 const double pi=acos(-1.0);

 const ll INF=0x3f3f3f3f3f3f3f3f;

 inline int dcmp(double x){

     if(fabs(x)<eps)    return ;

     return (x>? : -);

 }

 inline double sqr(double x){ return x*x; }

 struct Point{

     double x,y;

     Point(){ x=,y=; }

     Point(double _x,double _y):x(_x),y(_y){}

     void input(){ scanf("%lf%lf",&x,&y); }

     void output(){ printf("%.2f %.2f\n",x,y); }

     friend istream &operator >>(istream &os,Point &b){

         os>>b.x>>b.y;

         return os;

     }

     friend ostream &operator <<(ostream &os,Point &b){

         os<<b.x<<' '<<b.y;

         return os;

     }

     bool operator ==(const Point &b)const{

         return (dcmp(x-b.x)==&&dcmp(y-b.y)==);

     }

     bool operator !=(const Point &b)const{

         return !((dcmp(x-b.x)==&&dcmp(y-b.y)==));

     }

     bool operator <(const Point &b)const{

         return (dcmp(x-b.x)==? dcmp(y-b.y)< : x<b.x);

     }

     double operator ^(const Point &b)const{        //叉积

         return x*b.y-y*b.x;

     }

     double operator *(const Point &b)const{        //点积

         return x*b.x+y*b.y;

     }

     Point operator +(const Point &b)const{

         return Point(x+b.x,y+b.y);

     }

     Point operator -(const Point &b)const{

         return Point(x-b.x,y-b.y);

     }

     Point operator *(double a){

         return Point(x*a,y*a);

     }

     Point operator /(double a){

         return Point(x/a,y/a);

     }

     double len2(){    //长度平方

         return sqr(x)+sqr(y);

     }

     double len(){   //长度

         return sqrt(len2());

     }

     double polar(){    //向量的极角

         return atan2(y,x);     //返回与x轴正向夹角(-pi~pi]

     }

     Point change_len(double r){    //转化为长度为r的向量

         double l=len();

         if(dcmp(l)==)    return *this;  //零向量

         return Point(x*r/l,y*r/l);

     }

     Point rotate_left(){    //逆时针旋转90度

         return Point(-y,x);

     }

     Point rotate_right(){    //顺时针旋转90度

         return Point(y,-x);

     }

     Point rotate(Point p,double ang){    //绕点p逆时针旋转ang度

         Point v=(*this)-p;

         double c=cos(ang),s=sin(ang);

         return Point(p.x+v.x*c-v.y*s,p.y+v.x*s+v.y*c);

     }

     Point normal(){        //单位化，逆时针旋转90°

         return Point(-y/len(),x/len());

     }

 };

 inline double cross(Point a,Point b){    //叉积

     return a.x*b.y-a.y*b.x;

 }

 inline double dis(Point a,Point b){    //两点的距离

     Point p=b-a;    return p.len();

 }

 struct Line{

     Point s,e;

     Line(){}

     Line(Point _s,Point _e):s(_s),e(_e){} //两点确定直线

     double length(){    //线段长度

         return dis(s,e);

     }

 };

 double point_to_line(Point p,Line a){    //点到直线距离

     return fabs(cross(p-a.s,a.e-a.s)/a.length());

 }

 struct Circle{

     Point p;

     double r;

     Circle(){}

     Circle(Point _p,double _r):p(_p),r(_r){}

 };

 int relation(Line a,Circle b){    //直线和圆的位置关系  0:相离   1:相切   2:相交

     double p=point_to_line(b.p,a);

     if(dcmp(p-b.r)==)    return ;

     return (dcmp(p-b.r)<? : );

 }

 Point tmp[];

 int convex_hull(Point *p,int n,Point *ch){    //求凸包

     int m=;

     sort(p,p+n);

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

         while(m>&&dcmp(cross(tmp[m-]-tmp[m-],p[i]-tmp[m-]))<=)    m--;

         tmp[m++]=p[i];

     }

     int k=m;

     for(int i=n-;i>=;i--){

         while(m>k&&dcmp(cross(tmp[m-]-tmp[m-],p[i]-tmp[m-]))<=)    m--;

         tmp[m++]=p[i];

     }

     if(n>)    m--;

     for(int i=;i<m;i++)    ch[i]=tmp[i];

     return m;

 }

 int dp[][];

 Point point[];

 Circle circle[];

 bool rel[][];

 int main(void){

     int T;  scanf("%d",&T);

     while(T--){

         memset(dp,,sizeof(dp));

         memset(rel,,sizeof(rel));

         int n,m,ans=;    double r;   scanf("%d%d%lf",&n,&m,&r);

         for(int i=;i<n;i++)    point[i].input();

         for(int i=;i<m;i++)    circle[i].p.input(),circle[i].r=r;

         n=convex_hull(point,n,point);

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

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

                 int flag=;

                 for(int z=;z<m;z++)

                     if(relation(Line(point[i],point[j]),circle[z])){

                         flag=;

                         break;

                     }

                 if(flag)    rel[i][j]=rel[j][i]=;

             }

         for(int t=;t<*n;t++)

             for(int s=max(,t-n+);s<=t;s++)

                 for(int i=t;i>=s;i--)

                     dp[s][t]=max(dp[s][t],dp[s][i]+rel[s%n][t%n]);

         for(int i=n-;i<*n;i++)    ans=max(ans,dp[i-n+][i]);

         printf("%d\n",ans);

     }

     return ;

 }