#include <bits/stdc++.h>
using namespace std;
template <class c>
struct rge {
  c b, e;
};
template <class c>
rge<c> range(c i, c j) {
  return rge<c>{i, j};
}
template <class c>
auto dud(c* x) -> decltype(cerr << *x, 0);
template <class c>
char dud(...);
struct debug {
  template <class c>
  debug& operator<<(const c&) {
    return *this;
  }
};
const long long maxn = 1e6 + 5;
long long armatura[maxn];
struct segtree {
  struct node {
    long long mx;
    long long addVal;
  };
  vector<node> tree;
  long long size;
  const long long NEUTRAL_ELEMENT = -1e18;
  void build(long long x, long long lx, long long rx) {
    if (rx - lx == 1) {
      if (lx < maxn) {
        tree[x].mx = armatura[lx];
      }
    } else {
      long long mid = (lx + rx) / 2;
      build(2 * x + 1, lx, mid);
      build(2 * x + 2, mid, rx);
      tree[x].mx = max(tree[2 * x + 1].mx, tree[2 * x + 2].mx);
    }
  }
  void init() {
    size = 1;
    while (size < maxn) {
      size *= 2;
    }
    tree.resize(2 * size);
    build(0, 0, size);
  }
  void self_add(long long x, long long val) {
    tree[x].mx += val;
    tree[x].addVal += val;
  }
  void propagate(long long x, long long lx, long long rx) {
    if (rx - lx == 1) return;
    if (tree[x].addVal != 0LL) {
      self_add(2 * x + 1, tree[x].addVal);
      self_add(2 * x + 2, tree[x].addVal);
      tree[x].addVal = 0LL;
    }
  }
  long long rangeMax(long long x, long long lx, long long rx, long long l,
                     long long r) {
    propagate(x, lx, rx);
    if (lx >= r || rx <= l) {
      return NEUTRAL_ELEMENT;
    }
    if (lx >= l && rx <= r) {
      return tree[x].mx;
    }
    long long mid = (lx + rx) / 2;
    long long left = rangeMax(2 * x + 1, lx, mid, l, r);
    long long right = rangeMax(2 * x + 2, mid, rx, l, r);
    return max(left, right);
  }
  long long rangeMax(long long l, long long r) {
    return rangeMax(0, 0, size, l, r);
  }
  void add(long long x, long long lx, long long rx, long long l, long long r,
           long long val) {
    propagate(x, lx, rx);
    if (lx >= r || rx <= l) {
      return;
    }
    if (lx >= l && rx <= r) {
      self_add(x, val);
      return;
    }
    long long mid = (lx + rx) / 2;
    add(2 * x + 1, lx, mid, l, r, val);
    add(2 * x + 2, mid, rx, l, r, val);
    tree[x].mx = max(tree[2 * x + 1].mx, tree[2 * x + 2].mx);
  }
  void add(long long l, long long r, long long val) {
    add(0, 0, size, l, r, val);
  }
};
int32_t main() {
  ios::sync_with_stdio(false);
  cin.tie(0);
  long long n, m, p;
  cin >> n >> m >> p;
  map<long long, long long> armi;
  vector<array<long long, 4>> vals;
  long long ans = -1e18;
  for (long long i = 0; i < n; i++) {
    long long a, ca;
    cin >> a >> ca;
    if (!armi.count(a)) {
      armi[a] = ca;
    } else {
      armi[a] = min(armi[a], ca);
    }
  }
  for (long long i = 0; i < maxn; i++) {
    armatura[i] = -1e18;
  }
  for (long long i = 0; i < m; i++) {
    long long b, cb;
    cin >> b >> cb;
    armatura[b] = max(-cb, armatura[b]);
  }
  for (long long i = 0; i < p; i++) {
    long long dif, att, coins;
    cin >> dif >> att >> coins;
    vals.push_back({dif, 1LL, coins, att});
  }
  for (auto it : armi) {
    vals.push_back({it.first, 0LL, it.second, 0});
  }
  sort(vals.begin(), vals.end());
  for (auto it : vals) {
    debug() << " ["
            << "it"
               ": "
            << (it) << "] ";
  }
  segtree st;
  st.init();
  for (long long i = 0; i < vals.size(); i++) {
    if (vals[i][1] == 0) {
      long long ora = st.rangeMax(1, maxn - 1);
      debug() << " ["
              << "ora"
                 ": "
              << (ora) << "] ";
      ans = max(ora - vals[i][2], ans);
    } else {
      st.add(vals[i][3] + 1, maxn - 1, vals[i][2]);
    }
    debug() << " ["
            << "i"
               ": "
            << (i)
            << "] "
               " ["
            << "vals[i]"
               ": "
            << (vals[i])
            << "] "
               " ["
            << "ans"
               ": "
            << (ans) << "] ";
  }
  cout << ans << '\n';
}
