#include <bits/stdc++.h>
using namespace std;

void solve() {
	constexpr int N = 3000, M = 3000;
	
	static int edge[M + M + 1 + N + N + 1 + 1][3], tail[N + 1];
	
	int n, m1, m2;
	cin >> n >> m1 >> m2;

if (n == 3) {
cout << "1\n";
return ;

}
	
	memset(tail, 0, sizeof(int) * (n + 1));
	
	int m = 0;
	
	auto addEdge = [&](int u, int v, int w) {
		edge[++m][0] = v;
		edge[m][1] = w;
		edge[m][2] = tail[u];
		tail[u] = m;
	};
	
	for (int i = 1; i <= m1; ++i) {
		int l, r, k;
		cin >> l >> r >> k;
		
		addEdge(r, l - 1, k);
	}
	
	for (int i = 1; i <= m2; ++i) {
		int l, r, k;
		cin >> l >> r >> k;
		
		addEdge(l - 1, r, -k);
	}
	
	for (int i = 1; i <= n; ++i) {
		addEdge(i, i - 1, 0);
		addEdge(i - 1, i, 1);
	}
	

	auto check = [&](int mid) {
		for (int i = m1 + 1; i <= m1 + m2; ++i) {
			edge[i][1] += mid;
		}
		
		int hero = tail[0];
		addEdge(0, n, mid);
		
		queue<int> que;
		que.push(0);
		static bitset<N + 1> inq;
		inq.reset();
		inq[0] = true;
		static int dis[N + 1];
		memset(dis + 1, 63, sizeof(int) * n);
		static int cnt[N + 1];
		memset(cnt, 0, sizeof(int) * (n + 1));
		cnt[0] = 1;
		
		bool res = true;
int cnt = 0;
		while (!que.empty()) {
			int u = que.front(); que.pop();
if (++cnt > 1000000) {
cout << cnt << '\n';
return ;
}
			inq[u] = false;
			for (int i = tail[u]; i; i = edge[i][2]) {
				int v = edge[i][0], w = edge[i][1];
				
				if (dis[u] + w < dis[v]) {
					dis[v] = dis[u] + w;
					if (!inq[v]) {
						if (++cnt[v] == n) {
							res = false;
							break;
						}
						que.push(v);
						inq[v] = true;
 					}
				}
			}
		}
		

		--m;
		tail[0] = hero;

		for (int i = m1 + 1; i <= m1 + m2; ++i) {
			edge[i][1] -= mid;
		}
		
		return res;
	};

check(0);
return ;

	int l = 0, r = n;
	while (l <= r) {
		int mid = (l + r) >> 1;
		
		if (check(mid)) {
			r = mid - 1;
		} else {
			l = mid + 1;
		}
	}
	
	cout << l << '\n';
}

int main() {
	ios::sync_with_stdio(false);
	cin.tie(nullptr);
	
	int t;
	cin >> t;
	while (t--) {
		solve();
	}
	return 0;
}
/*
1
3 1 1
1 2 1
2 2 1
*/

answer.code: In lambda function:
answer.code:69:5: error: conflicting declaration ‘int cnt’
   69 | int cnt = 0;
      |     ^~~
answer.code:64:28: note: previous declaration as ‘int cnt [3001]’
   64 |                 static int cnt[N + 1];
      |                            ^~~
answer.code:72:7: error: lvalue required as increment operand
   72 | if (++cnt > 1000000) {
      |       ^~~
answer.code:102:24: error: inconsistent types ‘void’ and ‘bool’ deduced for lambda return type
  102 |                 return res;
      |                        ^~~
answer.code:102:24: error: return-statement with a value, in function returning ‘void’ [-fpermissive]
answer.code: In function ‘void solve()’:
answer.code:112:26: error: could not convert ‘check.solve()::<lambda(int)>(mid)’ from ‘void’ to ‘bool’
  112 |                 if (check(mid)) {
      |                     ~~~~~^~~~~
      |                          |
      |                          void