#include <bits/stdc++.h>
using namespace std;
const int N=1005; 
struct xb{
    double x,y,v;
}q[N];
struct poi{
    double x,y;
}p[N];
int n,m,t;
vector<int>e[N];
int vis[N];
int mch[N];
bool dfs(int u,int tag) {
    if(vis[u]==tag) return 0;
    vis[u]=tag;
    for (int i=0;i<e[u].size();i++){
        int v=e[u][i];
        if(!mch[v]||dfs(mch[v],tag)){
            mch[v]=u;
            return 1;
        }   
    }
    return 0;
}
int main(){
    cin>>m>>n>>t;
    int i,j,ans=0;
    for(i=1;i<=n;i++)
        scanf("%lf%lf",&p[i].x,&p[i].y);
    for(i=1;i<=m;i++)
        scanf("%lf%lf%lf",&q[i].x,&q[i].y,&q[i].v);
    for(i=1;i<=n;i++)
        for(j=1;j<=m;j++)
            if(pow(p[i].x-q[j].x,2)+pow(p[i].y-q[j].y,2)<=pow(q[j].v*t,2))
                e[i].push_back(j);
    for(i=1;i<=n;i++)
        if(dfs(i,i))
            ans++;
    printf("%d",ans);
    return 0;
}

#include <iostream>
#include <cstring>

using namespace std;

typedef struct
{
    double x,y,v;
}pp;

typedef struct
{
    double x,y;
}hole;

int n,m,t;
pp pps[1001];
hole hos[1001];
bool ma[1001][1001]={0};
bool vis[1001]={0};
int fa[1001]={0};

bool found(int x)
{
    int i;
    for(i=1;i<=m;i++)
    {
        if(ma[x][i]&&!vis[i])
        {
            vis[i]=true;
            if(fa[i]==0||found(fa[i]))
            {
                fa[i]=x;
                return true;
            }
        }
    }
    return false;
}

int main()
{
    cin>>m>>n>>t;
    int i,j,ans=0;
    for(i=1;i<=n;i++)
    {
        cin>>hos[i].x>>hos[i].y;
    }
    for(i=1;i<=m;i++)
    {
        cin>>pps[i].x>>pps[i].y>>pps[i].v;
    }
    for(i=1;i<=n;i++)
    {
        for(j=1;j<=m;j++)
        {
            if((hos[i].x-pps[j].x)*(hos[i].x-pps[j].x)+(hos[i].y-pps[j].y)*(hos[i].y-pps[j].y)<=(pps[j].v*t)*(pps[j].v*t))
            {
                ma[i][j]=true;
            }
        }
    }
    for(i=1;i<=n;i++)
    {
        memset(vis,0,sizeof(vis));
        if(found(i))
        {
            ans++;
        }
    }
    cout<<ans<<endl;
    return 0;
}

#include <cmath>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
using namespace std;

int n,m;
vector<int> l;
vector<vector<int> > a_b_r;
double t;
vector<double> a_x;
vector<double> a_y;
vector<double> a_v;
vector<double> b_x;
vector<double> b_y;
vector<bool> c;

void c_v_1()
{
    l.resize(0);
    a_b_r.resize(0);
    a_x.resize(0);
    a_y.resize(0);
    a_v.resize(0);
    b_x.resize(0);
    b_y.resize(0);
}

int find_1(int now)
{
    for (int i=1;i<a_b_r[now].size();i++)
        if (c[a_b_r[now][i]]==0)
        {
            int temp=l[a_b_r[now][i]];
            l[a_b_r[now][i]]=now,c[a_b_r[now][i]]=1;
            if (temp>0)
            {
                if (find_1(temp)==1)
                    return 1;
            }
            else
                return 1;
            l[a_b_r[now][i]]=temp;
        }
    return 0;
}

int work_1()
{
    int ans=0;
    for (int i=1;i<=n;i++)
    {
        c.resize(0);
        c.resize(m+1,0);
        ans+=find_1(i);
    }
    return ans;
}

int main()
{
    while (~scanf("%d%d%lf",&n,&m,&t))
    {
        c_v_1();
        b_x.resize(m+1,0);
        b_y.resize(m+1,0);
        for (int i=1;i<=m;i++)
            scanf("%lf%lf",&b_x[i],&b_y[i]);
        a_x.resize(n+1,0);
        a_y.resize(n+1,0);
        a_v.resize(n+1,0);
        for (int i=1;i<=n;i++)
            scanf("%lf%lf%lf",&a_x[i],&a_y[i],&a_v[i]);
        a_b_r.resize(n+1);
        for (int i=1;i<=n;i++)
        {
            a_b_r[i].resize(1,0);
            for (int j=1;j<=m;j++)
                if (pow(pow(fabs(a_x[i]-b_x[j]),double(2))+pow(fabs(a_y[i]-b_y[j]),double(2)),double(1)/2)<=a_v[i]*t)
                    a_b_r[i].push_back(j);
        }
        l.resize(m+1,0);
        printf("%d\n",work_1());
    }
}

#include<iostream>
#include<iomanip>
#include<cstring>
#include<vector>
#include<sstream>
#include<algorithm>
#include<string>
#include<cstdio>
#include<math.h>
#include<map>
#include<cctype>
#include<queue>
#include<functional>
#include<set>
#define lson l , m , rt << 1  
#define rson m + 1 , r , rt << 1 | 1  
#define Mem(a,b) memset((a),(b),sizeof((a)))
#define Sy system("pause")
const int maxn = 10000 + 10;
const int INF = 1e9;
using namespace std;
typedef long long LL;
struct Dinic{
    struct Edge {
        int from, to, cap, flow;
        Edge(int a, int b, int c, int d) :from(a), to(b), cap(c), flow(d) {}
        Edge(){}
        friend bool operator < (const Edge& a, const Edge& b) {
            return a.from < b.from || (a.from == b.from && a.to < b.to);
        }
    };

    int n, m, s, t;
    vector<Edge> old;
    vector<Edge> edges;//边数两倍
    vector<int> G[maxn];
    bool vis[maxn]; // BFS使用
    int d[maxn];
    int cur[maxn];

    void init(int n){ this->n = n; for (int i = 0; i < n; i += 1)G[i].clear(); edges.clear(); }

    void AddEdge(int from, int to, int cap){
        edges.push_back(Edge(from, to, cap, 0));
        edges.push_back(Edge(to, from, 0, 0));
        m = edges.size();
        G[from].push_back(m - 2);
        G[to].push_back(m - 1);
    }

    bool BFS(){  //构建层次网络，如果构建的时候汇点没有访问过证明已经不在网络中
        Mem(vis, 0);
        queue<int> Q;
        Q.push(s);
        vis[s] = 1;
        d[s] = 0;
        while (!Q.empty()){
            int x = Q.front(); Q.pop();
            for (int i = 0; i<G[x].size(); i += 1){
                Edge & e = edges[G[x][i]];
                if (!vis[e.to] && e.cap > e.flow){
                    vis[e.to] = 1;
                    d[e.to] = d[x] + 1;//层次
                    Q.push(e.to);
                }
            }
        }
        return vis[t];
    }

    int DFS(int x, int a){
        if (x == t || a == 0) return a;//如果已经到汇点或者增量是0，没必要继续因为已经找到了最大流
        int flow = 0, f;
        for (int & i = cur[x]; i<G[x].size(); i += 1){
            Edge& e = edges[G[x][i]];
            //如果e.to是x的儿子结点并且其增量大于0
            if (d[x] + 1 == d[e.to] && (f = DFS(e.to, min(a, e.cap - e.flow))) > 0){
                e.flow += f;
                edges[G[x][i] ^ 1].flow -= f;
                flow += f;
                a -= f;
                if (!a) break;
            }
        }
        return flow;
    }

    int MaxFlow(int s, int t){
        this->s = s; this->t = t;
        int flow = 0;
        while (BFS()){
            Mem(cur, 0);
            flow += DFS(s, INF);
        }
        return flow;
    }
};

//小杉家族r个人正在一片空地上散步，突然，外星人来了……
//留给小杉家族脱逃的时间只有t秒，每个小杉都有一个跑的速度v
//总共有a个传送点，小杉们必须在t秒内到达传送点才能脱逃
//每组测试数据的
//第一行有三个整数r和a和t(0<a, r, t <= 1000)
//第二行有a对实数，第i对数表示第i个传送点的坐标，这些坐标绝对值均不超过1e6
//接下来r行，每行有三个实数x, y, v，表示第i个小杉的坐标和奔跑的速度
// S:0 人：[1,r] 传送门：[r+1,r+a] T:r+a+1;
struct node
{
    float x, y, v;
    node(){}
    node(float a, float b, float c = 0.0) :x(a), y(b), v(c) {}
};
int r, a, t;
bool canrch(const node & a, const node & b){
    return (
        sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y)) <= (a.v * t)
        );
}
int main(){
    Dinic D;
    scanf("%d %d %d", &r, &a, &t);
    D.init(r + a + 2);
    float x, y, v;
    int s = 0, t = r + a + 1;
    vector<node> people, gate;
    for (int i = r + 1; i <= r + a; i += 1){
        scanf("%f %f", &x, &y);
        gate.push_back(node(x, y));
        D.AddEdge(i, t, 1);
    }
    for (int i = 1; i <= r; i += 1){
        scanf("%f %f %f", &x, &y, &v);
        people.push_back(node(x, y, v));
        D.AddEdge(s, i, 1);
    }
    for (int i = 1; i <= r; i += 1){
        node & p = people[i - 1];
        for (int j = 1; j <= a; j += 1){
            node & g = gate[j - 1];
            if (canrch(p, g))
                D.AddEdge(i, j + r, 1);
        }
    }
    printf("%d\n", D.MaxFlow(s, t));
    Sy;
    return 0;
}