#include <iostream>
#include <algorithm>
#include <vector>
#include <set>
#include <queue>
#include <map>
#include <bitset>
// #include <bit>
// #pragma GCC optimize("Ofast")
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<long long, long long> pll;
#define forn(i, n) for (int i = 0; i<n; i++)
#define forl(i, a, b) for (int i = a; i<b; i++)
#define spc << ' '
#define el << '\n'
#define nl cout << '\n'
#define pb push_back
#define sz size
#define fi first
#define se second
#define rsz resize
#define all(x) x.begin(), x.end()
const int inf = 1e9;
const ll inf2 = 1e18;

const int MAXN = 2005;
const int MAXC = 55;

struct cmp {
    int c, f, v;
};

bool operator < (const cmp& c1, const cmp& c2) {
    return c1.f<c2.f;
}

bool smax(ll& l1, const ll& l2) {
    if (l2>l1) {
        l1 = l2; return true;
    }
    return false;
}

int main() {
    cin.tie(NULL); ios_base::sync_with_stdio(false);
    int n; cin >> n;
    cmp a[n];
    forn(i,n) cin >> a[i].c >> a[i].f >> a[i].v;
    int m; cin >> m;
    cmp b[m];
    forn(i,m) cin >> b[i].c >> b[i].f >> b[i].v;
    sort(a,a+n);
    sort(b,b+m);

    ll dp[m+1][MAXC];
    pair<pair<short, short>, short> o[m+1][MAXC];
    vector<pair<int, short>> cl[m+1][MAXC+1];
    bitset<MAXN> u[m+1][MAXC];

    int p2 = n-1;
    forn(i,m+1) forn(j,MAXC) {
        dp[i][j] = -inf2;
        o[i][j] = {{0, 0}, n};
        u[i][j].reset();
    }
    dp[m][0] = 0;
    for (int i = m-1; i>=0; i--) {
        forn(j,MAXC) {
            cl[i][j+1] = cl[i+1][j+1];
            // if (i<m-1) {
            //     dp[i+1][j];
            //     u[i+1][j] = u[o[i+1][j].fi.fi][o[i+1][j].fi.se];
            //     u[i+1][j][o[i+1][j].se]=1;
            // }
        }
        cmp cc = b[i];
        for (; p2>=0 && a[p2].f >= cc.f; p2--) {
            auto p = lower_bound(all(cl[i][a[p2].c]), make_pair(a[p2].v, (short) p2));
            cl[i][a[p2].c].insert(p, {a[p2].v, p2});
        }
        forn(j, MAXC) {
            u[i+1][j] = u[o[i+1][j].fi.fi][o[i+1][j].fi.se];
            u[i+1][j][o[i+1][j].se]=1;
            if (j >= cc.c) {
                if (smax(dp[i][j-cc.c], dp[i+1][j] + cc.v)) {
                    o[i][j-cc.c] = {{i+1, j}, n};
                }
            }
            else {
                forl(k, 1, MAXC+1) {
                    for (auto l : cl[i][k]) {
                        if (!u[i+1][j][l.se]) {
                            if (j+k < MAXC) {
                                if (smax(dp[i+1][j+k], dp[i+1][j]-l.fi)) {
                                    o[i+1][j+k] = {{i+1, j}, l.se};
                                }
                            }
                            else {
                                if (smax(dp[i][j+k-cc.c], dp[i+1][j]-l.fi+cc.v)) {
                                    o[i][j+k-cc.c] = {{i+1, j}, l.se};
                                }
                            }
                            break;
                        }
                    }
                }
            }
            if (smax(dp[i][j], dp[i+1][j])) o[i][j] = {{i+1, j}, n};
        }
    }
    // forn(i,m+1) {
    //     forn(j, 12) {
    //         if (dp[i][j] > -100000) cout << dp[i][j] spc;
    //         else cout << ". ";
    //     }
    //     nl;
    // }
    // nl;
    cout << *max_element(dp[0], dp[0]+MAXC) << endl;
}