#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 1024000;
struct Node {
  int value;
  int action;
  bool hasAction;
};
const int NO_ACTION = 0;
const int NEUTRAL_QUERY_VALUE = 0;
int N;
Node allNodes[5 * MAX_N];
int baseValue[MAX_N];
int n, m, p;
int SubQueryMerge(int lhs_val, int rhs_val) { return max(lhs_val, rhs_val); }
void GenerateSegmentTree(int index, int nodeLeft, int nodeRight) {
  allNodes[index].action = NO_ACTION;
  if (nodeLeft == nodeRight) {
    allNodes[index].value = baseValue[nodeLeft];
    return;
  }
  int mid = (nodeLeft + nodeRight) / 2;
  GenerateSegmentTree(index * 2, nodeLeft, mid);
  GenerateSegmentTree(index * 2 + 1, mid + 1, nodeRight);
  allNodes[index].value =
      SubQueryMerge(allNodes[index * 2].value, allNodes[index * 2 + 1].value);
}
void AddLazyUpdateAction(int index, int action) {
  allNodes[index].action += action;
  allNodes[index].hasAction = true;
}
void ApplyAndPushLazyUpdate(int index, int nodeStart, int nodeEnd) {
  if (!allNodes[index].hasAction) return;
  allNodes[index].value += allNodes[index].action;
  if (nodeStart != nodeEnd) {
    int middle = (nodeStart + nodeEnd) / 2;
    AddLazyUpdateAction(index * 2, allNodes[index].action);
    AddLazyUpdateAction(index * 2 + 1, allNodes[index].action);
  }
  allNodes[index].action = NO_ACTION;
  allNodes[index].hasAction = false;
}
void ApplyLazyChange(int index, int nodeStart, int nodeEnd, int changeStart,
                     int changeEnd, int action) {
  ApplyAndPushLazyUpdate(index, nodeStart, nodeEnd);
  if (nodeEnd < changeStart || nodeStart > changeEnd) {
    return;
  }
  if (nodeStart >= changeStart && nodeEnd <= changeEnd) {
    AddLazyUpdateAction(index, action);
    ApplyAndPushLazyUpdate(index, nodeStart, nodeEnd);
    return;
  }
  int middle = (nodeStart + nodeEnd) / 2;
  ApplyLazyChange(index * 2, nodeStart, middle, changeStart, changeEnd, action);
  ApplyLazyChange(index * 2 + 1, middle + 1, nodeEnd, changeStart, changeEnd,
                  action);
  allNodes[index].value =
      SubQueryMerge(allNodes[index * 2].value, allNodes[index * 2 + 1].value);
}
int Query(int index, int nodeStart, int nodeEnd, int queryStart, int queryEnd) {
  if (nodeEnd < queryStart || nodeStart > queryEnd) return NEUTRAL_QUERY_VALUE;
  ApplyAndPushLazyUpdate(index, nodeStart, nodeEnd);
  if (nodeStart >= queryStart && nodeEnd <= queryEnd) {
    return allNodes[index].value;
  }
  int middle = (nodeStart + nodeEnd) / 2;
  int count = SubQueryMerge(
      Query(index * 2, nodeStart, middle, queryStart, queryEnd),
      Query(index * 2 + 1, middle + 1, nodeEnd, queryStart, queryEnd));
  return count;
}
int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);
  cin >> n >> m >> p;
  pair<int, int> weps[n];
  for (int i = 0; i < n; i++) {
    cin >> weps[i].first >> weps[i].second;
  }
  sort(weps, weps + n);
  pair<int, int> arms[m];
  for (int i = 0; i < m; i++) {
    cin >> arms[i].first >> arms[i].second;
  }
  sort(arms, arms + m);
  pair<pair<int, int>, int> monsters[p];
  for (int i = 0; i < p; i++) {
    cin >> monsters[i].first.first >> monsters[i].first.second >>
        monsters[i].second;
  }
  sort(monsters, monsters + p);
  int minarmor[p];
  pair<pair<int, int>, int> tempmonsters[p];
  for (int i = 0; i < p; i++) {
    tempmonsters[i] = make_pair(
        make_pair(monsters[i].first.second, monsters[i].first.first), i);
  }
  sort(tempmonsters, tempmonsters + p);
  int armind = 0;
  for (int i = 0; i < p; i++) {
    while (armind < p && arms[armind].first <= tempmonsters[i].first.first) {
      armind++;
    }
    minarmor[tempmonsters[i].second] = armind;
  }
  N = m;
  for (int i = 0; i < N; i++) {
    baseValue[i] = -arms[i].second;
  }
  GenerateSegmentTree(1, 0, N - 1);
  int out = -2e9;
  int nxtmonst = 0;
  for (int wepind = 0; wepind < n; wepind++) {
    while (nxtmonst < p &&
           weps[wepind].first > monsters[nxtmonst].first.first) {
      ApplyLazyChange(1, 0, N - 1, minarmor[nxtmonst], N - 1,
                      monsters[nxtmonst].second);
      nxtmonst++;
    }
    int wepcost = weps[wepind].second;
    int armcost = Query(1, 0, N - 1, 0, N - 1);
    out = max(out, armcost - wepcost);
  }
  cout << out << endl;
}
