/*

Sviatoslav Bidzilia 2019
CF: anakib1

*/

#include <iostream>
#include <cmath>
#include <algorithm>
#include <stdio.h>
#include <cstring>
#include <string>
#include <cstdlib>
#include <vector>
#include <bitset>
#include <map>
#include <chrono>
#include <unordered_set>
#include <unordered_map>
#include <numeric>
#include <queue>
#include <ctime>
#include <stack>
#include <set>
#include <list>
#include <deque>
#include <iomanip>
#include <sstream>
#include <fstream>
#include <stdarg.h>
#include <functional>
#include <utility>

using namespace std;

#define pb push_back
#define mp make_pair
#define ll long long
#define ull unisgned long long
#define ld long double
#define all(a) a.begin(), a.end()
#define SORT(a) sort(all(a))
#define pii pair<int, int>
#define tii triple<int, int, int>
#define e 1e-7
#define PI acos(-1)
#define inf 1e17
#define sz(a) (int)(a.size())
#define vi vector<int>
#define F first
#define S second
#define rng(x) for(int _ = 0; _ < (x); _++)
#define rngi(i, x) for(int i = 0; i < (x); i++)
#define rngsi(s, i, x) for(int i = (s); i <(x); i++)
#define int long long

template<typename A, typename B, typename C>
struct triple
{
	A X;
	B Y;
	C Z;
	triple(A a = 0, B b = 0, C c = 0) :X(a), Y(b), Z(c) {}
};
template<typename A, typename B, typename C>
triple<A, B, C> make_triple(A a = 0, B b = 0, C c = 0)
{
	return triple<A, B, C>(a, b, c);
}
template<typename A, typename B, typename C>
bool operator<(const triple<A, B, C>& a, const triple<A, B, C>& b)
{
	if (a.X != b.X)
		return a.X < b.X;
	if (a.Y != b.Y)
		return a.Y < b.Y;
	return a.Z < b.Z;
}
template<typename T, typename SS>
ostream& operator<<(ostream& ofs, const pair<T, SS>& p)
{
	ofs << "( " << p.F << " , " << p.S << " )";
	return ofs;
}
template<typename T>
void print(T a)
{
	for (auto i : a)
		cout << i << ' ';
	cout << '\n';
}
template<typename T>
T max(T a, T b, T c)
{
	return max(a, max(b, c));
}
template<typename T>
T min(T a, T b, T c)
{
	return min(a, min(b, c));
}
struct custom_hash
{
	static uint64_t splitmix64(uint64_t x)
	{
		x += 0x9e3779b97f4a7c15;
		x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
		x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
		return x ^ (x >> 31);
	}

	size_t operator()(uint64_t x) const
	{
		static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
		return splitmix64(x + FIXED_RANDOM);
	}
};
signed main()
{
	//freopen(".in", "r", stdin);
	//freopen(".out", "w", stdout);
	srand(time(NULL));
	cin.tie(0);
	cout.tie(0);
	ios_base::sync_with_stdio(false);
	int n, m, p;
	cin >> n >> m >> p;
	auto inp = [](int k){
		map<int, int> price;
		vi tmp;
		rng(k){
			int x, y; cin >> x >> y;
			tmp.pb(x);
			if (price.count(x)) price[x] = min(price[x], y);
			else price[x] = y;
		}
		SORT(tmp);
		vector<pii> a;
		int bst = inf;
		for (int i = k - 1; i >= 0; i--){
			if (price[tmp[i]] < bst)
				a.pb(mp(tmp[i], price[tmp[i]]));
			bst = min(bst, price[tmp[i]]);
		}
		return a;
	};
	auto a = inp(n), b = inp(m);
	map<int, int> p1, p2;
	for (auto x : a) p1[x.first] = x.second;
	for (auto x : b) p2[x.first] = x.second;
	vi x, y;
	for (auto xx : a) x.pb(xx.first);
	for (auto xy : b) y.pb(xy.first);
	vector<tii> mon(p); rngi(i, p) cin >> mon[i].X >> mon[i].Y >> mon[i].Z;
	SORT(mon);
	int now = 0;
	vi tree(4 * m, -inf), push(4 * m, 0);
	auto ps = [&](int v) {
		int& x = push[v];
		if (x) {
			tree[v << 1] += x;
			tree[v << 1 | 1] += x;
			push[v << 1] += x;
			push[v << 1 | 1] += x;
			x = 0;
		}
	};
	function<void(int, int, int, int, int)> st = [&](int v, int l, int r, int pos, int nv){
		if (l > r) return;
		if (l == r)return void(tree[v] = nv);
		int m = l + r >> 1;
		if (pos <= m) st(v << 1, l, m, pos, nv);
		else st(v << 1 | 1, m + 1, r, pos, nv);
		tree[v] = max(tree[v << 1], tree[v << 1 | 1]);
	};
	function<void(int, int, int, int, int, int)> ch = [&](int v, int l, int r, int _l, int _r, int xx){
		if (r < _l || _r < l) return;
		if (_l <= l && r <= _r)
		{
			tree[v] += xx;
			push[v] += xx;
			return;
		}
		int m = l + r >> 1;
		ps(v);
		ch(v << 1, l, m, _l, _r, xx);
		ch(v << 1 | 1, m + 1, r, _l, _r, xx);
		tree[v] = max(tree[v << 1], tree[v << 1 | 1]);
	};
	rngi(i, sz(y))
		st(1, 0, m - 1, i, -p2[y[i]]);
	int ans = -p1[x[0]] - p2[y[0]];
	for (auto r : mon){
		while (now < sz(x) && x[now] <= r.X) now++;
		if (now == sz(x)) break;
		int nw2 = upper_bound(all(y), r.Y) - y.begin();
		if (nw2 == sz(y)) break;
		ch(1, 0, m - 1, nw2, m - 1, r.Z);
		ans = max(ans, tree[1] - p1[x[now]]);
	}
	cout << ans << '\n';
}