#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ull unsigned long long
#define si(X) scanf("%d", &(X))
#define sll(X) scanf("%lld",&(X))
#define INFL 0x3f3f3f3f3f3f3f3fLL
const ll mod = 1e9 + 7;

ll gcd(ll a,ll b){if(b==0)return a;return gcd(b,a%b);}
ll expo(ll base,ll pow){ll ans = 1;
   while(pow!=0){if(pow&1==1){ans = ans*base;ans = ans%mod;}
   base *= base;base%=mod;pow/=2;}return ans;}
ll inv(ll x){return expo(x,mod-2);}
int dx[8] = {1 , 0 , -1 , 0 , 1 , -1 , -1 , 1};    // last 4 diagonal
int dy[8] = {0 , 1 , 0 , -1 , 1 , 1 , -1 , -1};
/*---------------------------------------------------------------------------------------------------------------------*/

const int M = 4e5 + 5;

int p[M];

struct Data{
    int y , mi , ma , start , end;
};
Data cloud[M] , for_cloud[M];
ll people_at[M];
int cloud_start[M] , cloud_end[M];

map<ll , ll> mappedTo , revMap;
ll till = 1;

bool ok(ll x){
    if(mappedTo.count(x)) return false;
    return true;
}
void inMap(ll x , int typ , int ind){
	int inc = 0;
	ll here = 0;
	if(typ == 0){   // town here
	    if(ok(x)){
	        mappedTo[x]  = till;
	        revMap[till] = x;
	        here = till;
	        inc = 1;
	    }
	    else{
	        here = mappedTo[x];
	    }
	    people_at[here] += p[ind];
	   // people[till]    = 1;
	}
	else if(typ == 1){  // cloud starts here
	    if(ok(x)){
	        mappedTo[x]  = till;
	        revMap[till] = x;
	        here = till;
	        inc = 1;
	    }
	    else{
	        here = mappedTo[x];
	    }
	    cloud_start[here]++;
	    for_cloud[ind].start = here;
	}
	else{
	    if(ok(x)){
	        mappedTo[x]  = till;
	        revMap[till] = x;
	        here = till;
	        inc = 1;
	    }
	    else{
	        here = mappedTo[x];
	    }
	    cloud_end[here]   += 1;
	    for_cloud[ind].end = here;
	}
	till += inc;
}
ll segTree[4*M];

void build(int node , int l , int r){
    if(l > r) return;
    if(l == r){
        segTree[node] = people_at[l];
        //cout<<node<<"  "<<l<<"  "<<people_at[l]<<endl;
        return;
    }
    int mid = (l + r)/2;
    build(2*node , l , mid);
    build(2*node + 1 , mid + 1 , r);
    segTree[node] = segTree[2*node] + segTree[2*node + 1];
}

ll get(int node , int l , int r , int ql , int qr){
   // cout<<l<<"  "<<r<<"  "<<ql<<"  "<<qr<<endl;
    if(l > r || ql > qr || l > qr || r < ql) return 0;
    if(l >= ql && r <= qr) return segTree[node];
    int mid = (l + r)/2;
    ll a = get(2*node , l , mid , ql , qr);
    ll b = get(2*node + 1 , mid + 1 , r , ql , qr);
    return (a + b);
}

vector<pair<int , pair<int , int> > > vec;

int main(){
    
	
	int n , m;
	si(n);  
	
	ll tot = 0;
	
	for(int i = 1 ; i <= n ; i++){
	    si(p[i]);
	    tot += p[i];
	}
	
	
	for(int i = 1 ; i <= n ; i++){
	    int pos;
	    si(pos);
	    vec.push_back(make_pair(pos , make_pair(0 , i)));
	    //inMap(pos , 0 , i);
	}
	
	si(m);
	
	for(int i = 1 ; i <= m ; i++){
	    si(cloud[i].y);
	}
	
	for(int i = 1 ; i <= m ; i++){
	    int r;
	    si(r);
	    cloud[i].mi = cloud[i].y - r;
	    cloud[i].ma = cloud[i].y + r;
	    vec.push_back(make_pair(cloud[i].mi , make_pair(1 , i)));
	    vec.push_back(make_pair(cloud[i].ma + 1 , make_pair(2 , i)));
	    //inMap(cloud[i].mi , 1 , i);
	    //inMap(cloud[i].ma ,2 , i);
	}
	sort(vec.begin() , vec.end());
	for(int i = 0 ; i < vec.size() ; i++){
	    inMap(vec[i].first , vec[i].second.first , vec[i].second.second);
	}
	int clouds = 0;
	ll one = 0 , ans = 0;
	
	for(int i = 1 ; i < till ; i++){
	    clouds += (cloud_start[i] - cloud_end[i]);
	    //cout<<i<<"  "<<revMap[i]<<"  "<<clouds<<endl;
	    if(clouds > 1) people_at[i] = 0;
	    if(clouds == 0) ans += people_at[i];
	    if(clouds == 1) one += people_at[i];
	}
	
	till--;
	
	build(1 , 1 , till);
//	cout<<"how"<<endl;
	
	ll temp = 0;
	for(int i = 1 ; i <= m ; i++){
	    int L = for_cloud[i].start;
	    int R = for_cloud[i].end;
	    ll tw = get(1 , 1 , till , L , R - 1);
	    temp = max(temp , tw);
	}
	
	ans += temp;
	cout<<ans;
    
}