#include <bits/stdc++.h>
using namespace std;
struct attack {
  long long num, val;
  bool operator<(const attack& a) const {
    if (num == a.num) return val < a.val;
    return num < a.num;
  }
} attack[200005], define[200005];
struct mon {
  long long att, def, val;
  bool operator<(const mon& m) const {
    if (def == m.def) return val < m.val;
    return def < m.def;
  }
} mon[200005];
struct node {
  long long l, r, maxn, lazy;
} a[1000010 * 4];
void update(int k) { a[k].maxn = max(a[2 * k].maxn, a[2 * k + 1].maxn); }
void build(int k, int l, int r) {
  a[k].l = l;
  a[k].r = r;
  if (l == r) {
    a[k].maxn = 0;
    a[k].lazy = 0;
    return;
  }
  int mid = l + (r - l) / 2;
  build(2 * k, l, mid);
  build(2 * k + 1, mid + 1, r);
  update(k);
}
void pushdown(int k) {
  if (a[k].l == a[k].r) {
    a[k].lazy = 0;
    return;
  }
  int left = 2 * k;
  int right = 2 * k + 1;
  a[left].maxn += a[k].lazy;
  a[right].maxn += a[k].lazy;
  a[left].lazy += a[k].lazy;
  a[right].lazy += a[k].lazy;
  a[k].lazy = 0;
}
void change(int k, int l, int r, long long x) {
  if (a[k].l == l && a[k].r == r) {
    a[k].maxn += x;
    a[k].lazy += x;
    return;
  }
  if (a[k].lazy) pushdown(k);
  int mid = a[k].l + (a[k].r - a[k].l) / 2;
  if (r <= mid)
    change(2 * k, l, r, x);
  else if (l > mid)
    change(2 * k + 1, l, r, x);
  else {
    change(2 * k, l, mid, x);
    change(2 * k + 1, mid + 1, r, x);
  }
  update(k);
}
long long query(int k, int l, int r) {
  if (a[k].lazy) pushdown(k);
  if (a[k].l == l && a[k].r == r) return a[k].maxn;
  int mid = a[k].l + (a[k].r - a[k].l) / 2;
  if (r <= mid)
    return query(2 * k, l, r);
  else if (l > mid)
    return query(2 * k + 1, l, r);
  else
    return max(query(2 * k, l, mid), query(2 * k + 1, mid + 1, r));
}
int main() {
  ios::sync_with_stdio(false);
  cin.tie(0);
  int n, m, p;
  long long minx = 1e9, miny = 1e9;
  cin >> n >> m >> p;
  for (int i = 1; i <= n; i++) {
    cin >> attack[i].num >> attack[i].val;
    minx = min(minx, attack[i].val);
  }
  build(1, 1, 1e6 + 5);
  sort(attack + 1, attack + 1 + n);
  long long begin = 1;
  for (int i = 1; i <= n; i++) {
    if (begin > attack[i].num) continue;
    change(1, begin, attack[i].num, -attack[i].val);
    begin = attack[i].num + 1;
  }
  if (begin <= 1e6 + 5) change(1, begin, 1e6 + 5, -1e12);
  for (int i = 1; i <= m; i++) {
    cin >> define[i].num >> define[i].val;
    miny = min(miny, define[i].val);
  }
  sort(define + 1, define + 1 + m);
  for (int i = 1; i <= p; i++) {
    cin >> mon[i].att >> mon[i].def >> mon[i].val;
  }
  sort(mon + 1, mon + 1 + p);
  int index = 1;
  long long ans = -(minx + miny);
  for (int i = 1; i <= m; i++) {
    while (mon[index].def < define[i].num) {
      change(1, mon[index].att + 1, 1e6 + 5, mon[index].val);
      ans = max(ans, query(1, 1, 1e6 + 5) - define[i].val);
      index++;
      if (index > p) break;
    }
    if (index > p) break;
  }
  cout << ans << '\n';
  return 0;
}
