superhedgy

#include <bits/stdc++.h>

using namespace std;
ifstream fin("superhedgy.in");
ofstream fout("superhedgy.out");
const int N = 1000002;
int n, m, i;
int64_t Lmax;
long long Lu, Ld;
struct cladire {
    int L, H, E;
    cladire() { L = H = E = 0; }
};

cladire U[N], D[N];
int main() {
    assert(fin >> n);
    assert(1 <= n && n <= 100000);
    for (i = 1; i <= n; i++) {
        assert(fin >> U[i].L >> U[i].H >> U[i].E);
        Lmax += U[i].L;
        Lu += U[i].L;
        assert(1 <= U[i].L && U[i].L <= 2000000000);
        assert(1 <= U[i].H && U[i].H <= 1000000000);
        assert(0 <= U[i].E && U[i].E <= 1000000000);
    }
    assert(fin >> m);
    assert(1 <= m && m <= 100000);
    for (i = 1; i <= m; i++) {
        assert(fin >> D[i].L >> D[i].H >> D[i].E);
        Lmax += D[i].L;
        Ld += D[i].L;
        assert(1 <= D[i].L && D[i].L <= 2000000000);
        assert(1 <= D[i].H && D[i].H <= 1000000000);
        assert(0 <= D[i].E && D[i].E <= 1000000000);
    }
    Lmax /= 2;
    assert(Lu == Ld);
    int i = 0, j = 0;
    int64_t solU = 0, solD = 0;
    while (i <= n && j <= m) {
        int lg = min(U[i].L, D[j].L);
        solU += lg;
        U[i].L -= lg;
        solD += lg;
        D[j].L -= lg;
        int64_t elevator = U[i].E + D[j].E;
        int64_t vertU = U[i].L ? 0 : abs(U[i].H - U[i + 1].H);
        int64_t vertD = D[j].L ? 0 : abs(D[j].H - D[j + 1].H);
        int64_t auxU = solU;
        int64_t auxD = solD;
        solU = min(auxU + vertU, auxD + elevator + vertU);
        solD = min(auxD + vertD, auxU + elevator + vertD);
        i = i + (U[i].L == 0);
        j = j + (D[j].L == 0);
    }
    fout << min(solU, solD);
    return 0;
}