#include <bits/stdc++.h>
using namespace std;
typedef struct P {
  int x, y;
  P() {}
  P(int x, int y) : x(x), y(y) {}
} P;
typedef struct F {
  int x, y, r;
} F;
bool operator<(const F &a, const F &b) { return a.r < b.r; }
vector<int> parent;
vector<vector<int> > memupp;
int upp(int a, int p) {
  assert(((int)(memupp[a]).size()) > 0);
  while (p >= ((int)(memupp[a]).size())) {
    int i = ((int)(memupp[a]).size()) - 1;
    memupp[a].push_back(upp(upp(a, i), i));
  }
  return memupp[a][p];
}
int up(int a, int cnt) {
  for (int i = 0; i <= cnt; ++i)
    if ((cnt & (1 << i)) != 0) {
      cnt -= 1 << i;
      a = upp(a, i);
    }
  return a;
}
bool contains(const F &f, const P &p) {
  return (long long)(f.x - p.x) * (f.x - p.x) +
             (long long)(f.y - p.y) * (f.y - p.y) <=
         (long long)f.r * f.r;
}
void gen(int xl, int xr, int yl, int yr, vector<F> &f) {
  if (xl > xr || yl > yr) return;
  int xm = xl + (xr - xl) / 2;
  int ym = yl + (yr - yl) / 2;
  int r = min(min(xr - xm, xm - xl), min(yr - ym, ym - yl));
  if (r <= 0) return;
  f.push_back((F){xm, ym, r});
  gen(xm - r / 2, xm - 1, ym - r / 2, ym - 1, f);
  gen(xm - r / 2, xm - 1, ym + 1, ym + r / 2, f);
  gen(xm + 1, xm + r / 2, ym - r / 2, ym - 1, f);
  gen(xm + 1, xm + r / 2, ym + 1, ym + r / 2, f);
}
void run() {
  int ncontrol, nfence, nq;
  scanf("%d%d%d", &ncontrol, &nfence, &nq);
  vector<P> p(ncontrol);
  for (int i = (0); i < (ncontrol); ++i) scanf("%d%d", &p[i].x, &p[i].y);
  vector<F> f(nfence);
  for (int i = (0); i < (nfence); ++i)
    scanf("%d%d%d", &f[i].r, &f[i].x, &f[i].y);
  sort(f.begin(), f.end());
  vector<int> c2f(ncontrol, -1);
  for (int i = (0); i < (ncontrol); ++i)
    for (int j = (0); j < (nfence); ++j)
      if (contains(f[j], p[i])) {
        c2f[i] = j;
        break;
      }
  parent = vector<int>(nfence, -1);
  for (int i = (0); i < (nfence); ++i)
    for (int j = (i + 1); j < (nfence); ++j)
      if (contains(f[j], P(f[i].x, f[i].y))) {
        parent[i] = j;
        break;
      }
  vector<int> depth(nfence, -1);
  vector<int> root(nfence, -1);
  for (int i = (0); i < (nfence); ++i)
    if (parent[i] == -1) depth[i] = 0, root[i] = i;
  for (int i = (0); i < (nfence); ++i)
    if (depth[i] == -1) {
      vector<int> path;
      int at = i;
      while (depth[at] == -1) {
        path.push_back(at);
        at = parent[at];
      }
      for (int j = ((int)(path).size()) - 1; j >= 0; --j) {
        at = path[j];
        depth[at] = depth[parent[at]] + 1, root[at] = root[parent[at]];
      }
    }
  memupp = vector<vector<int> >(nfence);
  for (int i = (0); i < (nfence); ++i)
    if (parent[i] != -1) memupp[i].push_back(parent[i]);
  vector<int> ans(nq);
  for (int q = (0); q < (nq); ++q) {
    int a, b;
    scanf("%d%d", &a, &b);
    --a, --b;
    int aa = a + 1, bb = b + 1;
    a = c2f[a], b = c2f[b];
    if (a == -1 && b == -1) {
      ans[q] = 0;
      continue;
    }
    if (a == -1) {
      ans[q] = depth[b] + 1;
      continue;
    }
    if (b == -1) {
      ans[q] = depth[a] + 1;
      continue;
    }
    if (root[a] != root[b]) {
      ans[q] = depth[a] + 1 + depth[b] + 1;
      continue;
    }
    int cur = 0;
    if (depth[a] > depth[b]) {
      cur += depth[a] - depth[b];
      a = up(a, depth[a] - depth[b]);
    }
    if (depth[b] > depth[a]) {
      cur += depth[b] - depth[a];
      b = up(b, depth[b] - depth[a]);
    }
    assert(depth[a] == depth[b]);
    if (a == b) {
      ans[q] = cur;
      continue;
    }
    int maxupp = 0;
    while ((1 << (maxupp + 1)) <= depth[a]) ++maxupp;
    for (int i = maxupp; i >= 0; --i) {
      if ((1 << i) > depth[a]) continue;
      int aa = upp(a, i), bb = upp(b, i);
      if (aa != bb) {
        cur += 2 << i;
        a = aa, b = bb;
      }
    }
    assert(parent[a] == parent[b]);
    ans[q] = cur + 2;
  }
  for (int i = (0); i < (nq); ++i) printf("%d\n", ans[i]);
}
int main() {
  run();
  return 0;
}
