#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:64000000")
using namespace std;
long long sqr(int x) { return 1LL * x * x; }
bool In(int x, int y, int cx, int cy, int r) {
  return sqr(x - cx) + sqr(y - cy) < 1LL * r * r;
}
void dfs(int v, vector<bool>& used, vector<vector<int> >& al,
         vector<vector<int> >& childs, vector<int>& prev) {
  if (used[v]) return;
  used[v] = true;
  for (int i = 0; i < al[v].size(); ++i) {
    int v2 = al[v][i];
    if (used[v2]) continue;
    childs[v].push_back(v2);
    prev[v2] = v;
    dfs(v2, used, al, childs, prev);
  }
}
void dfs_o(int v, vector<bool>& used, vector<vector<int> >& childs,
           vector<int>& order) {
  if (used[v]) return;
  order.push_back(v);
  used[v] = true;
  for (int i = 0; i < childs[v].size(); ++i) {
    dfs_o(childs[v][i], used, childs, order);
    order.push_back(v);
  }
}
void MakeTable(vector<int>& a, vector<vector<int> >& table) {
  int n = a.size();
  int log_n = 1;
  while ((1 << log_n) < n) ++log_n;
  table.resize(log_n + 1);
  table[0].assign((a).begin(), (a).end());
  for (int L = 1; L <= log_n; ++L) {
    table[L].resize(a.size());
    int step = (1 << L);
    for (int i = 0; i + step - 1 < a.size(); ++i)
      table[L][i] = min(table[L - 1][i], table[L - 1][i + (step >> 1)]);
  }
}
int GetMin(int a, int b, vector<vector<int> >& table) {
  if (b < a) swap(a, b);
  int len = b - a + 1;
  int k = 0;
  while (1 << (k + 1) <= len) ++k;
  return min(table[k][a], table[k][b + 1 - (1 << k)]);
}
vector<int> cx, cy;
vector<long long> r;
vector<int> x, y;
int dp[1000 + 1];
int Get(int j, vector<vector<int> >& al) {
  if (dp[j] >= 0) return dp[j];
  int X = x[j];
  int Y = y[j];
  int pos = r.size() - 1;
  bool ch = true;
  while (ch) {
    ch = false;
    for (int i = 0; i < al[pos].size(); ++i) {
      int c = al[pos][i];
      if (In(X, Y, cx[c], cy[c], r[c])) {
        pos = c;
        ch = true;
        break;
      }
    }
  }
  return dp[j] = pos;
}
int cmp(int i, int j) { return r[i] > r[j]; }
int main() {
  memset(dp, -1, sizeof(dp));
  int n, m, k;
  cin >> n >> m >> k;
  x.resize(n);
  y.resize(n);
  for (int i = 0; i < n; ++i) scanf("%d%d", &x[i], &y[i]);
  r.resize(m);
  cx.resize(m);
  cy.resize(m);
  for (int i = 0; i < m; ++i) {
    scanf("%d%d%d", &r[i], &cx[i], &cy[i]);
  }
  r.push_back(2000LL * 1000 * 1000);
  cx.push_back(0);
  cy.push_back(0);
  vector<vector<int> > al(m + 1, vector<int>(0));
  for (int i = 0; i < m + 1; ++i) {
    for (int j = 0; j < m + 1; ++j) {
      if (i != j && In(cx[j], cy[j], cx[i], cy[i], r[i]) && r[i] > r[j])
        al[i].push_back(j);
    }
  }
  for (int i = 0; i < m + 1; ++i) ::sort((al[i]).begin(), (al[i]).end(), cmp);
  vector<bool> used(m + 1, false);
  vector<vector<int> > childs(m + 1, vector<int>(0));
  vector<int> prev(m + 1, -1);
  dfs(m, used, al, childs, prev);
  vector<int> order;
  used.assign(m + 1, false);
  dfs_o(m, used, childs, order);
  vector<int> first(m + 1, ((1 << 31) - 1));
  for (int i = 0; i < order.size(); ++i) {
    first[order[i]] = min(first[order[i]], i);
  }
  vector<int> depth(m + 1, ((1 << 31) - 1));
  queue<int> Q;
  Q.push(m);
  depth[m] = 0;
  while (!Q.empty()) {
    int v = Q.front();
    Q.pop();
    for (int i = 0; i < childs[v].size(); ++i) {
      int v2 = childs[v][i];
      depth[v2] = depth[v] + 1;
      Q.push(v2);
    }
  }
  vector<int> a;
  for (int i = 0; i < order.size(); ++i) a.push_back(depth[order[i]]);
  vector<vector<int> > table;
  MakeTable(a, table);
  while (k-- > 0) {
    int v1, v2;
    scanf("%d%d", &v1, &v2);
    v1 = Get(v1 - 1, al);
    v2 = Get(v2 - 1, al);
    printf("%d\n",
           depth[v1] + depth[v2] - 2 * GetMin(first[v1], first[v2], table));
  }
  return 0;
}
