#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
const int MAXV = 10;
const int MAXP = 100000;
const int MAXQ = 100000;
typedef struct P {
  int x, y;
  P() {}
  P(int x, int y) : x(x), y(y) {}
} P;
P operator+(const P &a, const P &b) { return P(a.x + b.x, a.y + b.y); }
P operator-(const P &a, const P &b) { return P(a.x - b.x, a.y - b.y); }
long long operator^(const P &a, const P &b) {
  return (long long)a.x * b.y - (long long)a.y * b.x;
}
bool operator<(const P &a, const P &b) {
  if (a.x != b.x) return a.x < b.x;
  return a.y < b.y;
}
long long side(const P &a, const P &b, const P &c) { return (b - a) ^ (c - a); }
typedef struct R {
  long long x;
  long long val;
  int mlt, idx;
  R() {}
  R(long long x, long long val, int mlt, int idx)
      : x(x), val(val), mlt(mlt), idx(idx) {}
} R;
bool operator<(const R &a, const R &b) { return a.x < b.x; }
vector<P> calchull(vector<P> p) {
  sort(p.begin(), p.end());
  vector<P> ret;
  ret.push_back(p[0]);
  int nret;
  nret = ((int)(ret).size());
  for (int i = (0); i < (((int)(p).size())); ++i) {
    while (((int)(ret).size()) - nret > 0 &&
           side(ret[((int)(ret).size()) - 2], ret[((int)(ret).size()) - 1],
                p[i]) <= 0)
      ret.pop_back();
    ret.push_back(p[i]);
  }
  nret = ((int)(ret).size());
  for (int i = ((int)(p).size()) - 1; i >= 0; --i) {
    while (((int)(ret).size()) - nret > 0 &&
           side(ret[((int)(ret).size()) - 2], ret[((int)(ret).size()) - 1],
                p[i]) <= 0)
      ret.pop_back();
    ret.push_back(p[i]);
  }
  ret.pop_back();
  return ret;
}
int nv, np, nq;
P v[MAXV];
P p[MAXP];
int pcnt[MAXP];
P q[MAXQ];
int qt[MAXQ];
R a[MAXP];
int na;
R b[2 * MAXQ];
int nb;
long long c[MAXP];
int nc;
long long ans[MAXQ];
long long bt[MAXP + 1];
void bmod(int idx, int by) {
  ++idx;
  while (idx <= nc) {
    bt[idx] += by;
    idx += idx & -idx;
  }
}
long long bget(int idx) {
  long long ret = 0;
  ++idx;
  while (idx > 0) {
    ret += bt[idx];
    idx -= idx & -idx;
  }
  return ret;
}
void solve(int it) {
  nc = 0;
  for (int i = (0); i < (na); ++i) c[nc++] = a[i].val;
  sort(c, c + nc);
  nc = unique(c, c + nc) - c;
  for (int i = (0); i <= (nc); ++i) bt[i] = 0;
  sort(a, a + na);
  sort(b, b + nb);
  int ai = 0;
  for (int bi = (0); bi < (nb); ++bi) {
    while (ai < na && a[ai].x <= b[bi].x) {
      int aidx = lower_bound(c, c + nc, a[ai].val) - c;
      bmod(aidx, a[ai].mlt);
      ++ai;
    }
    int bidx = lower_bound(c, c + nc, b[bi].val) - c;
    if (bidx == nc || c[bidx] > b[bi].val) --bidx;
    long long cur = bget(bidx);
    ans[b[bi].idx] += cur * b[bi].mlt;
  }
}
void run() {
  scanf("%d%d%d", &nv, &np, &nq);
  for (int i = (0); i < (nv); ++i) scanf("%d%d", &v[i].x, &v[i].y);
  for (int i = (0); i < (np); ++i) scanf("%d%d%d", &p[i].x, &p[i].y, &pcnt[i]);
  for (int i = (0); i < (nq); ++i) scanf("%d%d%d", &q[i].x, &q[i].y, &qt[i]);
  vector<P> hull;
  hull.push_back(P(0, 0));
  for (int i = (0); i < (nv); ++i) {
    vector<P> nhull;
    for (int j = (0); j < (((int)(hull).size())); ++j)
      nhull.push_back(hull[j] + v[i]), nhull.push_back(hull[j] - v[i]);
    hull = calchull(nhull);
  }
  int xmx = hull[0].x;
  for (int i = (1); i < (((int)(hull).size())); ++i) xmx = max(xmx, hull[i].x);
  for (int i = (0); i < (nq); ++i) ans[i] = 0;
  for (int it = (0); it < (((int)(hull).size())); ++it) {
    P A = hull[it], B = hull[(it + 1) % ((int)(hull).size())];
    int lx = A.x, ly = A.y, rx = B.x, ry = B.y;
    bool swapped = false;
    if (lx == rx) continue;
    if (lx > rx) swap(lx, rx), swap(ly, ry), swapped = true;
    int dx = rx - lx, dy = ry - ly;
    na = nb = 0;
    for (int i = (0); i < (np); ++i) {
      int x = p[i].x, y = p[i].y;
      a[na++] = R(x, (long long)y * dx - (long long)x * dy, pcnt[i], i);
    }
    for (int i = (0); i < (nq); ++i) {
      long long lqx = q[i].x + (long long)qt[i] * lx,
                lqy = q[i].y + (long long)qt[i] * ly,
                rqx = q[i].x + (long long)qt[i] * rx;
      b[nb++] =
          R(rx == xmx ? rqx : rqx - 1,
            lqy * dx - lqx * dy + (!swapped ? -1 : 0), !swapped ? -1 : +1, i);
      b[nb++] = R(lqx - 1, lqy * dx - lqx * dy + (!swapped ? -1 : 0),
                  !swapped ? +1 : -1, i);
    }
    solve(it);
  }
  for (int i = (0); i < (nq); ++i) printf("%lld\n", ans[i]);
}
int main() {
  run();
  return 0;
}
