#include <bits/stdc++.h>
using namespace std;
class RMQ_ST {
 private:
  const static int RMQ_LOGMAX = 20;
  const static int RMQ_MAXN = 202000;
  vector<int> intLen;
  int M[RMQ_MAXN][RMQ_LOGMAX];

 public:
  vector<int> value;

 private:
  int N;
  inline int getIntLen(int key) {
    int len = 0;
    while (key > 0) {
      len++;
      key >>= 1;
    }
    return len;
  }

 public:
  RMQ_ST(int n) {
    N = n;
    intLen = vector<int>(N);
    value = vector<int>(N);
    for (int i = 0; i < N; ++i) intLen[i] = getIntLen(i);
  }
  inline void setValue(int posi, int value) { this->value[posi] = value; }
  void initRMQ() {
    for (int i = 0; i < N; ++i) M[i][0] = i;
    for (int j = 1; (1 << j) <= N; ++j) {
      int upper = N + 1 - (1 << j);
      int step = 1 << (j - 1);
      for (int i = 0; i < upper; ++i) {
        if (value[M[i][j - 1]] < value[M[i + step][j - 1]])
          M[i][j] = M[i][j - 1];
        else
          M[i][j] = M[i + step][j - 1];
      }
    }
  }
  int RMQ_value(int start, int stop) {
    int k = (stop - start + 1);
    k = intLen[k] - 1;
    return min(value[M[start][k]], value[M[stop - (1 << k) + 1][k]]);
  }
  int RMQ_posi(int start, int stop) {
    int k = (stop - start + 1);
    k = intLen[k] - 1;
    if (value[M[start][k]] <= value[M[stop - (1 << k) + 1][k]])
      return M[start][k];
    else
      return M[stop - (1 << k) + 1][k];
  }
};
int N, M, K;
inline long long sqr(long long x) { return x * x; }
class Circle {
 public:
  long long x, y, r;
  bool operator<(const Circle& other) const { return r < other.r; }
  bool inCircle(const Circle& other) const {
    return sqr(x - other.x) + sqr(y - other.y) < other.r * other.r &&
           r < other.r;
  }
};
Circle cir[2000];
long long x[2000];
long long y[2000];
int inWhich[2000];
vector<vector<int> > tree;
vector<vector<int> > revTree;
vector<int> dfsID;
vector<int> depth;
vector<bool> visited;
vector<int> dfsDepth;
vector<int> firstApp;
RMQ_ST rmq(200000);
void dfs(int now, int father, int nowDepth) {
  visited[now] = true;
  depth[now] = nowDepth;
  dfsID.push_back(now);
  dfsDepth.push_back(nowDepth);
  firstApp[now] = dfsID.size() - 1;
  for (int i = 0; i < tree[now].size(); ++i) {
    int next = tree[now][i];
    if (next == father) continue;
    dfs(next, now, nowDepth + 1);
    dfsID.push_back(now);
    dfsDepth.push_back(nowDepth);
  }
}
void deal() {
  depth = vector<int>(M + 1, 0);
  visited = vector<bool>(M + 1, false);
  firstApp = vector<int>(M + 1);
  dfs(M, -1, 0);
  for (int i = 0; i < dfsDepth.size(); ++i) {
    rmq.setValue(i, dfsDepth[i]);
  }
  rmq.initRMQ();
  for (int i = 0; i < K; ++i) {
    int t1, t2;
    scanf("%d%d", &t1, &t2);
    t1--;
    t2--;
    t1 = inWhich[t1];
    t2 = inWhich[t2];
    int s1 = firstApp[t1];
    int s2 = firstApp[t2];
    if (s1 > s2) swap(s1, s2);
    int ans = rmq.RMQ_value(s1, s2);
    printf("%d\n", depth[t1] + depth[t2] - 2 * ans);
  }
}
void init() {
  scanf("%d%d%d", &N, &M, &K);
  int t1, t2, t3;
  for (int i = 0; i < N; ++i) {
    scanf("%d%d", &t1, &t2);
    x[i] = t1;
    y[i] = t2;
  }
  for (int i = 0; i < M; ++i) {
    scanf("%d%d%d", &t1, &t2, &t3);
    cir[i].r = t1;
    cir[i].x = t2;
    cir[i].y = t3;
  }
  sort(cir, cir + M);
  tree.resize(M + 1);
  revTree.resize(M + 1);
  for (int i = 0; i < M; ++i) {
    for (int j = i + 1; j < M; ++j)
      if (cir[i].inCircle(cir[j])) {
        tree[j].push_back(i);
        revTree[i].push_back(j);
        break;
      }
  }
  for (int i = 0; i < M; ++i)
    if (revTree[i].size() == 0) tree[M].push_back(i);
  for (int i = 0; i < N; ++i) {
    inWhich[i] = M;
    for (int j = 0; j < M; ++j)
      if (sqr(x[i] - cir[j].x) + sqr(y[i] - cir[j].y) <= cir[j].r * cir[j].r) {
        inWhich[i] = j;
        break;
      }
  }
}
int main() {
  init();
  deal();
  return 0;
}
