#include <bits/stdc++.h>
using namespace std;
const int DIV = 1000000007;
struct Monster {
  int x, y, z;
};
struct SegmentTreeInterval {
 private:
  int n;
  vector<int> tsum, tmax;
  void build(const std::vector<int> &a, int v, int tl, int tr) {
    if (tl == tr) {
      tsum[v] = a[tl];
      tmax[v] = a[tl];
    } else {
      int tm = (tl + tr) / 2;
      build(a, v * 2, tl, tm);
      build(a, v * 2 + 1, tm + 1, tr);
      tmax[v] = max(tmax[v * 2], tmax[v * 2 + 1]);
    }
  }
  void update(int v, int tl, int tr, int l, int r, int add) {
    if (l > r) return;
    if (l == tl && tr == r) {
      tsum[v] += add;
      tmax[v] += add;
    } else {
      int tm = (tl + tr) / 2;
      update(v * 2, tl, tm, l, min(r, tm), add);
      update(v * 2 + 1, tm + 1, tr, max(l, tm + 1), r, add);
      tmax[v] = tsum[v] + max(tmax[v * 2], tmax[v * 2 + 1]);
    }
  }
  int getElem(int v, int tl, int tr, int pos) {
    if (tl == tr) return tsum[v];
    int tm = (tl + tr) / 2;
    if (pos <= tm)
      return tsum[v] + getElem(v * 2, tl, tm, pos);
    else
      return tsum[v] + getElem(v * 2 + 1, tm + 1, tr, pos);
  }
  int getMax(int v, int tl, int tr, int l, int r) {
    if (l > r) return -INT32_MIN;
    if (l == tl && r == tr) return tmax[v];
    int tm = (tl + tr) / 2;
    int t1 = getMax(v * 2, tl, tm, l, min(r, tm));
    int t2 = getMax(v * 2 + 1, tm + 1, tr, max(l, tm + 1), r);
    return tsum[v] + max(t1, t2);
  }

 public:
  SegmentTreeInterval(int n) : n(n), tsum(n * 4, 0), tmax(n * 4, INT32_MIN) {}
  void build(const std::vector<int> &a) { build(a, 1, 0, n - 1); }
  void update(int l, int r, int add) { update(1, 0, n - 1, l, r, add); }
  int getElem(int pos) { return getElem(1, 0, n - 1, pos); }
  int getMax(int l, int r) { return getMax(1, 0, n - 1, l, r); }
};
void check() {
  int n = 101;
  vector<int> a(n);
  for (int i = 0; i < n; i++) {
    a[i] = rand() % 100;
  }
  SegmentTreeInterval segTree(n);
  segTree.build(a);
  for (int test = 0; test < 1000; test++) {
    if (true) {
      int l = rand() % n;
      int r = (rand() % (n - l)) + l;
      int add = rand() % 100;
      for (int i = l; i <= r; i++) {
        a[i] += add;
      }
      segTree.update(l, r, add);
    }
    if (true) {
      for (int l = 0; l < n; l++) {
        for (int r = l; r < n; r++) {
          int realRes = -1;
          for (int i = l; i <= r; i++) {
            realRes = max(realRes, a[i]);
          }
          int res = segTree.getMax(l, r);
          if (res != realRes) {
            printf("Error max!\n");
          }
        }
      }
      for (int i = 0; i < n; i++) {
        int realRes = a[i];
        int res = segTree.getElem(i);
        if (res != realRes) {
          printf("Error elem!\n");
        }
      }
    }
  }
  printf("Finished!\n");
}
int main(int argc, char *argv[]) {
  istream &f = cin;
  int n, m, p;
  f >> n >> m >> p;
  vector<int> a(n), ca(n), b(m), cb(m);
  vector<Monster> monster(p);
  for (int i = 0; i < n; i++) {
    f >> a[i] >> ca[i];
  }
  for (int i = 0; i < m; i++) {
    f >> b[i] >> cb[i];
  }
  for (int i = 0; i < p; i++) {
    f >> monster[i].x >> monster[i].y >> monster[i].z;
  }
  sort(monster.begin(), monster.end(),
       [](const Monster &a, const Monster &b) -> bool { return a.x < b.x; });
  vector<pair<int, int>> bp(m);
  for (int i = 0; i < m; i++) {
    bp[i] = make_pair(b[i], i);
  }
  sort(bp.begin(), bp.end());
  vector<int> barr(m);
  for (int i = 0; i < m; i++) {
    barr[i] = -cb[bp[i].second];
    b[i] = bp[i].first;
  }
  SegmentTreeInterval segTree(m);
  segTree.build(barr);
  vector<pair<int, int>> ap(n);
  for (int i = 0; i < n; i++) {
    ap[i] = make_pair(a[i], i);
  }
  sort(ap.begin(), ap.end());
  int answer = 0;
  int mIdx = 0;
  for (int i = 0; i < n; i++) {
    int curAnswer = -ca[ap[i].second];
    while (mIdx < p && ap[i].first > monster[mIdx].x) {
      auto it = std::upper_bound(b.begin(), b.end(), monster[mIdx].y);
      int idx = it - b.begin();
      if (idx < m) {
        segTree.update(idx, m - 1, monster[mIdx].z);
      }
      mIdx++;
    }
    curAnswer += segTree.getMax(0, m - 1);
    if (i == 0 || curAnswer > answer) answer = curAnswer;
  }
  printf("%d\n", answer);
  return 0;
}
