#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>

using namespace std;
using namespace __gnu_pbds;

#define cint(d) scanf("%d", &d)
#define cint2(a, b) scanf("%d %d", &a, &b)
#define cint3(a, b, c) scanf("%d %d %d", &a, &b, &c)
#define cint4(a, b, c, d) scanf("%d %d %d %d", &a, &b, &c, &d)

#define clong(d) scanf("%lld", &d)
#define clong2(a, b) scanf("%lld %lld", &a, &b)
#define clong3(a, b, c) scanf("%lld %lld %lld", &a, &b, &c)
#define clong4(a, b, c, d) scanf("%lld %lld %lld %lld", &a, &b, &c, &d)

#define foreach(v, c) for(__typeof( (c).begin()) v = (c).begin();  v != (c).end(); ++v)
#define revforeach(v, c) for(__typeof( (c).rbegin()) v = (c).rbegin();  v != (c).rend(); ++v)
#define ALL(v) (v).begin(), (v).end()

#define pb push_back
#define eb emplace_back
#define mp make_pair
#define fi first
#define se second

typedef long long int slong;

typedef pair<int, int> pii;
typedef pair<slong, slong> pll;
typedef tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update> pbds;
typedef set<int>::iterator sit;
typedef map<int,int>::iterator mit;
typedef vector<int>::iterator vit;

#ifdef VSP4 
    #include "debug.h"    
#else
    #define debug(args...)                  // Just strip off all debug tokens
#endif

const int MOD = 1000000007;
#define MODSET(d) if ((d) >= MOD) d %= MOD;
#define MODNEGSET(d) if ((d) < 0) d = ((d % MOD) + MOD) % MOD;
#define MODADDSET(d) if ((d) >= MOD) d -= MOD;
#define MODADDWHILESET(d) while ((d) >= MOD) d -= MOD;

const int MAXN = 5e5;
const int SQRTN = 650;
const int LOGN = 18;
const int INT_INFINITY = 1001001001;

const slong LONG_INFINITY = 1001001001001001001ll;
const slong LONG_LIMIT = 200100100100101ll;

const slong MAX_LIMIT = 1000000000000000000ll;

const int LIMIT = (1 << 16);

int n, m;
int p[MAXN+5], x[MAXN+5];
int y[MAXN+5], r[MAXN+5];
int arr[MAXN+5];

struct node
{
	node *left, *right;
	slong sum;
	
	node (slong sum, node *left, node *right)
	{
		this->sum = sum;
		this->left = left;
		this->right = right;
	}
	
	node (node *left, node *right)
	{
		this->sum = left->sum + right->sum;
		this->left = left;
		this->right = right;
	}
	
	node* insert(int l, int r, int index, int val);
	slong query(int l, int r, int qLow, int qHigh);
};

node* null;

node* node::insert(int l, int r, int index, int val)
{
	if (l <= index && index <= r)
	{
		if (l == r)
		{
			return new node(this->sum + val, null, null);
		}
		else
		{
			int mid = (l+r)/2;
			return new node(this->left->insert(l, mid, index, val), this->right->insert(mid+1, r, index, val));
		}
	}
	else
	{
		return this;
	}
}


slong node::query(int l, int r, int qLow, int qHigh)
{
	if (r < qLow || qHigh < l)
	{
		return 0;
	}
	else
	{
		if (qLow <= l && r <= qHigh)
		{
			return this->sum;
		}
		else
		{
			int mid = (l+r)/2;			
			return this->left->query(l, mid, qLow, qHigh) + this->right->query(mid+1, r, qLow, qHigh);
		}
	}
}

int add[2*MAXN+5];

int main()
{
	#ifdef VSP4
		freopen("input.txt", "r", stdin);
		freopen("output.txt", "w", stdout);
	#endif
	
	clock_t begin = clock();
	
    int t, i, j, d;
    
	null = new node(0, NULL, NULL);
	null->left = null->right = null;
	
    cint(n);
    
    for (i = 1; i <= n; i++)
    {
		cint(p[i]);
	}
	
	map<int, int> compress;
	
    for (i = 1; i <= n; i++)
    {
		cint(x[i]);
		compress[x[i]];
	}
	
	cint(m);
	
    for (i = 1; i <= m; i++)
    {
		cint(y[i]);
	}
	
    for (i = 1; i <= m; i++)
    {
		cint(r[i]);
	}
	
    for (i = 1; i <= m; i++)
    {
		int ll = max(0, y[i] - r[i]);
		int rr = min(MOD, y[i] + r[i]);
		compress[ll];
		compress[rr];		
	}
		
	i = 0;
	for (auto &s: compress)
	{
		s.se = ++i;
	}
	
	
    for (i = 1; i <= m; i++)
    {
		int ll = compress[max(0, y[i] - r[i])];
		int rr = compress[min(MOD, y[i] + r[i])];
		add[ll]++;
		add[rr+1]--;
	}
	
	for (i = 1; i <= 2*MAXN; i++)
	{
		add[i] += add[i-1];
	}
	
	slong always = 0;
	
	node* root = null;
	
    for (i = 1; i <= n; i++)
    {
		int val = compress[x[i]];
		if (add[val] == 0)
		{
			always += p[i];
		}
		else if (add[val] == 1)
		{
			root = root->insert(0, MOD, val, p[i]);
		}
	}
	
	slong ans = always;
	
	for (i = 1; i <= m; i++)
	{
		int ll = compress[max(0, y[i] - r[i])];
		int rr = compress[min(MOD, y[i] + r[i])];
		ans = max(ans, always + root->query(0, MOD, ll, rr));
	}
	
	cout << ans;
	
	
	
	clock_t end = clock();
	double elapsed_secs = double(end - begin) / CLOCKS_PER_SEC;

	cerr << elapsed_secs;
	
	return 0;
}