#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ldb;
typedef pair<int, int> pii;
const int MAXN = 1e5 + 5;
const int MAXQ = 1e5 + 5;
const int MAXD = 5e5 + 5;

struct BIT {
    int tree[MAXD], n;
#define lowbit(x) ((x)&-(x))
    inline void update(int x, int k) {
        while (x <= n)
            tree[x] += k,
                       x += lowbit(x);
    }
    inline void update(int l, int r, int k) {
        update(l, k);
        update(r + 1, -k);
    }
    inline int query(int x) {
        int res = 0;

        while (x)
            res += tree[x],
                   x ^= lowbit(x);

        return res;
    }
} tree;

int begy[MAXN], enny[MAXN];

int fa[MAXN];
int find(int u) {
    return fa[u] == u ? u : fa[u] = find(fa[u]);
}

int main(void) {
    int n, A, B, C, begx, ennx;
    scanf("%d%d%d%d%d%d", &n, &A, &B, &C, &begx, &ennx);

    for (int i = 1; i <= n; ++i)
        scanf("%d", &begy[i]);

    for (int i = 1; i <= n; ++i)
        scanf("%d", &enny[i]);

    const ll BASE = 1e10;

    set<pii> t;
    vector< pair<ll, ll>> pt;

    for (int i = n; i >= 1; --i) {
        auto it = t.begin();

        for (; it != t.end() && it -> first < enny[i]; ++it) {
            int j = it -> second;
            ldb
            k1 = (ldb)(enny[i] - begy[i]) / (ennx - begx),
            k2 = (ldb)(enny[j] - begy[j]) / (ennx - begx),
            dx = (begy[j] - begy[i]) / (k1 - k2),
            x = begx + dx,
            y = begy[i] + dx * k1;
            pt.emplace_back(round((x + y) * BASE), round((x - y) * BASE));
        }

        t.emplace_hint(it, enny[i], i);
    }

    static ll dsc[MAXD];
    int dcnt = 0;

    for (auto it : pt)
        dsc[++dcnt] = it.second;

    sort(dsc + 1, dsc + dcnt + 1);
    dcnt = unique(dsc + 1, dsc + dcnt + 1) - dsc - 1;

    int Q;
    scanf("%d", &Q);
    vector< tuple<ll, int, int, int>> eff;

    while (Q--) {
        int x, y, r;
        scanf("%d%d%d", &x, &y, &r);
        tie(x, y) = make_tuple(x + y, x - y);

        int yl = lower_bound(dsc + 1, dsc + dcnt + 1, (y - r) * BASE) - dsc;
        int yr = upper_bound(dsc + 1, dsc + dcnt + 1, (y + r) * BASE) - dsc - 1;

        if (yl > yr)
            continue;

        eff.emplace_back((x - r) * BASE, 1, yl, yr);
        eff.emplace_back((x + r) * BASE + 1, 2, yl, yr);
    }

    int useC = 0;
    tree.n = dcnt;
    sort(pt.begin(), pt.end());
    sort(eff.begin(), eff.end());

    for (int i = 0, j = 0; i < (int)pt.size(); ++i) {
        for (; j < (int)eff.size() && get<0>(eff[j]) <= pt[i].first; ++j)
            tree.update(get<2>(eff[j]), get<3>(eff[j]), get<1>(eff[j]) == 1 ? 1 : -1);

        int cury = lower_bound(dsc + 1, dsc + dcnt + 1, pt[i].second) - dsc;

        if (tree.query(cury))
            ++useC;
    }

    static int ord[MAXN];
    iota(ord + 1, ord + n + 1, 1);
    sort(ord + 1, ord + n + 1, [&](int x, int y) {
        return enny[x] < enny[y];
    });
    iota(fa + 1, fa + n + 1, 1);
    int ccnt = n;

    for (int i = 1; i <= n; ++i)
        if (find(i) != find(ord[i])) {
            --ccnt;
            fa[find(i)] = find(ord[i]);
        }

    int cr = (int)pt.size();
    int must = n - ccnt;
    ll ans1 = (ll)cr * A, ans2 = (ll)must * A + (ll)(cr - must) * B;
    ans1 += (ll)useC * C;
    ans2 += (ll)useC * C;

    if (ans1 > ans2)
        swap(ans1, ans2);

    printf("%lld %lld", ans1, ans2);
    return 0;
}