#include <bits/stdc++.h>
using namespace std;
const int maxp = 22;
const long double EPS = 1e-18;
const long long INF = 2e18;
const int MOD = 1e9 + 7;
const int N = 1e6 + 1;
struct ano {
  int def, atk, val;
  bool operator<(const ano &x) const { return def < x.def; }
};
template <typename T>
struct SEGTREE {
  struct node {
    T val;
    T lazy;
    node() : val(0), lazy(0) {}
    node(T _val) : val(_val), lazy(0) {}
  };
  vector<node> seg;
  int N;
  void init(int n) {
    N = n;
    seg.assign(4 * n, node());
  }
  node merge(node x, node y) {
    node res;
    res.val = max(x.val, y.val);
    return res;
  }
  void push(node &par, node &x, node &y, int r1, int r2) {
    x.val += par.lazy;
    x.lazy += par.lazy;
    y.val += par.lazy;
    y.lazy += par.lazy;
    par.lazy = 0;
  }
  void build(int s, int e, int idx, T arr[]) {
    if (s == e) {
      seg[idx] = node(arr[s]);
      return;
    }
    int mid = (s + e) / 2;
    build(s, mid, idx * 2, arr);
    build(mid + 1, e, idx * 2 + 1, arr);
    seg[idx] = merge(seg[idx * 2], seg[idx * 2 + 1]);
  }
  void build(T arr[]) { build(1, N, 1, arr); }
  void update(int s, int e, int idx, int qs, int qe, T val) {
    if (qs <= s && e <= qe) {
      seg[idx].val += val;
      seg[idx].lazy += val;
      return;
    }
    if (s > qe || e < qs) return;
    int mid = (s + e) / 2;
    push(seg[idx], seg[idx * 2], seg[idx * 2 + 1], mid - s + 1, e - mid);
    update(s, mid, idx * 2, qs, qe, val);
    update(mid + 1, e, idx * 2 + 1, qs, qe, val);
    seg[idx] = merge(seg[idx * 2], seg[idx * 2 + 1]);
  }
  void update(int l, int r, T val) { update(1, N, 1, l, r, val); }
  node query(int s, int e, int idx, int qs, int qe) {
    if (qs <= s && e <= qe) return seg[idx];
    if (s > qe || e < qs) return node();
    int mid = (s + e) / 2;
    push(seg[idx], seg[idx * 2], seg[idx * 2 + 1], mid - s + 1, e - mid);
    return merge(query(s, mid, idx * 2, qs, qe),
                 query(mid + 1, e, idx * 2 + 1, qs, qe));
  }
  T query(int l, int r) { return query(1, N, 1, l, r).val; }
};
int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(nullptr);
  int n, m, p;
  cin >> n >> m >> p;
  pair<int, int> atk[n];
  int i;
  for (i = 0; i < n; i++) {
    cin >> atk[i].first >> atk[i].second;
  }
  sort(atk, atk + n);
  pair<int, int> def[m];
  for (i = 0; i < m; i++) {
    cin >> def[i].first >> def[i].second;
  }
  sort(def, def + m);
  ano arr[p];
  for (i = 0; i < p; i++) {
    cin >> arr[i].def >> arr[i].atk >> arr[i].val;
  }
  sort(arr, arr + p);
  SEGTREE<long long> seg;
  seg.init(N - 1);
  long long temp[N];
  for (i = 1; i < N; i++) {
    temp[i] = -INF;
  }
  for (i = 0; i < m; i++) {
    temp[def[i].first] = max(temp[def[i].first], (long long)-def[i].second);
  }
  seg.build(temp);
  int pos = 0;
  long long ans = -INF;
  for (i = 0; i < n; i++) {
    while (pos < p && arr[pos].def < atk[i].first) {
      seg.update(arr[pos].atk + 1, N, arr[pos].val);
      pos++;
    }
    ans = max(ans, seg.query(1, N) - atk[i].second);
  }
  cout << ans;
}
