#include <bits/stdc++.h>

//#define DEBUG 1

#define int long long
#define for0(i,n) for (int i=0; i<n; i++)
#define iter(c) for(auto it=c.begin(); it!=c.end(); it++)
#define iter2(c) for(auto it2=c.begin(); it2!=c.end(); it2++)
#define pb push_back
#define ms(a,z) memset(a,z,sizeof(a));
#define mp make_pair
#define X first
#define Y second
#define max(a,b) ((a)>(b)?(a):(b))
#define min(a,b) ((a)<(b)?(a):(b))
#define all(a) a.begin(),a.end()
#define sz(x) (int)(x).size()
#define pmod(x,m) (((x)%(m)+m)%m)
#ifdef int
#define read(x) scanf("%lld",&x);
#else
#define read(x) scanf("%d",&x);
#endif

#ifdef DEBUG
#define nl cout<<"\n";
#define pr(x) cout<<(x)<<" ";
#define prl(x) cout<<#x " = "<<x<<endl;
#define prp(x) cout<<"("<<(x).first<<" "<<(x).second<<") ";
#define printv(v) {for(int _=0; _<sz(v); _++) cout<<v[_]<<" "; cout<<"\n";}
#define printa(a,s) {for (int _=0; _<s; _++) cout<<a[_]<<" "; cout<<"\n";}
#define print2D(a,m,n) {for (int _=0; _<m; _++) {for (int __=0; __<n; __++) cout<<a[_][__]<<" "; cout<<"\n";} cout<<"\n";}
#define priter(v) iter(v) {pr(*it)} nl
#define debug cout<<"ok at line "<<__LINE__<<endl;
#else
#define nl
#define pr(x)
#define prl(x)
#define prp(x)
#define printv(v)
#define printa(a,s)
#define print2D(a,m,n)
#define priter(v)
#define debug
#endif
#define MAXN 200000

using namespace std;

typedef long long ll;

const int INF = 2147483647;
const long long INFL = 9223372036854775807LL;
const double EPSILON = 0.00000001;
const long long MOD = 1000000007;

struct interval {
    int l,r,i;
    interval(int l, int r, int i) : l(l), r(r), i(i)
    {}
};
typedef set<interval,bool(*)(interval,interval)> interval_set;
class IntervalTree
{
public:
    static bool comp_inc_l(interval a, interval b) {
        if (a.l == b.l) {
            //just to distinguish the intervals
            if (a.r == b.r)
                return a.i < b.i;
            return a.r < b.r; 
        }
        return a.l < b.l;
    }
    static bool comp_inc_r(interval a, interval b) {
        if (a.r == b.r) {
             //just to distinguish the intervals
            if (a.l == b.l)
                return a.i < b.i;
            return a.l < b.l;
        }
        return a.r < b.r;
    }
    static bool comp_dec_r(interval a, interval b) {
        if (a.r == b.r) {
            //just to distinguish the intervals
            if (a.l == b.l)
                return a.i < b.i;
            return a.l < b.l; 
        }
        return a.r > b.r;
    }
    static void print_interval_set(interval_set & S) {
        for (interval it : S) 
            cout<<"("<<it.l<<","<<it.r<<") ";
        cout<<endl;
    }
    
    bool(*comp_inc_l_ptr)(interval,interval);
    bool(*comp_inc_r_ptr)(interval,interval);
    bool(*comp_dec_r_ptr)(interval,interval);

    struct node 
    {
        int x_center;
        interval_set S_l;
        interval_set S_r;
        node *left_child, *right_child;
        node(int x_center, interval_set& S) : x_center(x_center), left_child(nullptr), right_child(nullptr)
        {
            bool(*comp_inc_l_ptr)(interval,interval) = IntervalTree::comp_inc_l;
            bool(*comp_dec_r_ptr)(interval,interval) = IntervalTree::comp_dec_r;
            S_l = interval_set(comp_inc_l_ptr);
            S_r = interval_set(comp_dec_r_ptr);
            for (interval it : S) {
                S_l.insert(it);
                S_r.insert(it);
            }
        }
    };    
    
    node * root;
    
    IntervalTree() {}
    IntervalTree(interval_set& S) {
        comp_inc_l_ptr = comp_inc_l;
        comp_inc_r_ptr = comp_inc_r;
        comp_dec_r_ptr = comp_dec_r;
        root = construct(S);
    }
    
    node * construct(interval_set& S) {
        if (S.empty())
            return nullptr;
        interval_set S_left(comp_inc_r_ptr);
        interval_set S_right(comp_inc_r_ptr);
        interval_set S_mid(comp_inc_r_ptr);
        int x_center;
        
        interval_set::iterator it = S.begin();
        while ((int)S_left.size() < ((int)S.size()+1)/2 and it != S.end()) {
            S_left.insert(*it);
            it++;
        }
        auto S_left_back = S_left.end();
        S_left_back--;
        x_center = S_left_back->r;
        S_mid.insert(*S_left_back);
        S_left.erase(S_left_back);
        
        for (; it!=S.end(); it++) {
            if (it->l <= x_center and x_center <= it->r)
                S_mid.insert(*it);
            else {
                assert(it->l > x_center);
                S_right.insert(*it);
            }
        }
        node * nd = new node(x_center, S_mid);
        nd->left_child = construct(S_left);
        nd->right_child = construct(S_right);
        
        return nd;
    }
    
    /***
    Returns a vector of all intervals overlapping with x.
    If delete_results is true, all returned intervals will be 
    deleted from the tree. 
    ***/
    vector<interval> get_overlap(int x, bool delete_results) 
    {
        vector<interval> results;
        node * cur = root;
        while (cur != nullptr) {
            int tmp = results.size();
            if (x <= cur->x_center) {
                //Go through intervals in this node in increasing order of l.
                //For all these intervals, r >= x_center >= x, so if l <= x 
                //then they overlap 
                for (auto it=cur->S_l.begin(); it!=cur->S_l.end(); it++) {
                    if (it->l <= x) {
                        //this interval overlaps 
                        results.push_back(*it);
                        if (sz(results) >= 2)
                            return results;
                    }
                    else 
                        //no more intervals here overlap
                        break; 
                }
                if (delete_results) {
                    for (int i=tmp; i<results.size(); i++) {
                        cur->S_l.erase(results[i]);
                        cur->S_r.erase(results[i]);
                    }
                }
                cur = cur->left_child;
            }
            else {
                //Go through intervals in decreasing order of r. 
                //Since l <= x_center < x, all these intervals overlap iff x <= r 
                for (auto it=cur->S_r.begin(); it!=cur->S_r.end(); it++) {
                    if (x <= it->r) {
                        //this interval overlaps;
                        results.push_back(*it);
                        if (sz(results) >= 2)
                            return results;
                    }
                    else 
                        //no more intervals here overlap
                        break; 
                }
                if (delete_results) {
                    for (int i=tmp; i<results.size(); i++) {
                        cur->S_l.erase(results[i]);
                        cur->S_r.erase(results[i]);
                    }
                }
                cur = cur->right_child;
            }
        }        
        return results;
    } 
};

ll pops[MAXN+5], cities[MAXN+5], clouds[MAXN+5], cloud_ranges[MAXN+5];
ll scores[MAXN+5];

int32_t main()
{
    #ifdef DEBUG
    //freopen("B.txt","r",stdin);
    //freopen("","w",stdout);
    #endif

    int n,m;
    cin >> n;
    for0(i,n) {
        read(pops[i]);
    }
    for0(i,n) {
        read(cities[i]);
    }
    cin >> m;
    for0(i,m) {
        read(clouds[i]);
    }
    for0(i,m) {
        read(cloud_ranges[i]);
    }
    
    bool(*fn_pt)(interval,interval) = IntervalTree::comp_inc_r;
    interval_set S(fn_pt);
    for0(i,m) {
        S.insert(interval(clouds[i]-cloud_ranges[i], clouds[i]+cloud_ranges[i], i));
    }    
    IntervalTree interval_tree = IntervalTree(S);
    
    ms(scores,0);
    ll base_cnt = 0;
    for0(i,n) {
        vector<interval> overlaps = interval_tree.get_overlap(cities[i],false);
        if (sz(overlaps) == 1) {
            scores[overlaps[0].i] += pops[i];
        }
        else if (sz(overlaps) == 0) {
            base_cnt +=  pops[i];
        }
    }
    
    ll best = 0;
    for (int i=0; i<m; i++) {
        best = max(best,scores[i]);
    }
    prl(best)
    prl(base_cnt)
    cout<<best+base_cnt<<endl;
    return 0;
}