import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;

public class Solution {
    
    static class City implements Comparable<City>{
        public long x, p, cover, cj;
        public City(long x, long p, long cover, long cj){
            this.x = x; this.p = p; this.cover = cover; this.cj = cj;
        }
        
        public int compareTo(City other){
            return (int)(this.x - other.x);
        }
        
        public String toString(){
            return x+" "+p+" "+cover+" "+cj;
        }
    }
    
    static long maximumPeople(long[] x, long[] p, long[] y, long[] r) {
        long people = 0;
        TreeSet<City> cities = new TreeSet<City>(); 
        
        for(int i=0; i<p.length; i++){
            cities.add(new City(x[i], p[i], 0, -1));
        }
        
        for(int i=0; i<y.length; i++){
            for(City c : cities){
                System.out.println(c.x+" . "+(y[i]+r[i]));
                if(c.x > y[i]+r[i] || c.cover > 1) break;

                if(c.x >= (y[i]-r[i]) && c.x <= y[i]+r[i]){
                    c.cover ++;
                    c.cj = i;
                }
            }
        }
        
        System.out.println(cities);
        
        long not_covered = 0;
        HashMap<Long, Long> values = new HashMap<Long, Long>();
        for(City c : cities){
            if(c.cover == 0) not_covered += c.p;
            else{
                if(c.cover == 1){
                    if(values.containsKey(c.cj)){
                        values.put(c.cj, values.get(c.cj)+c.p);
                    }else{
                        values.put(c.cj, c.p);
                    }
                }
            }
        }
        
        long max_covered = 0;
        
        for(Long key : values.keySet()){
            if(values.get(key) > max_covered) max_covered = values.get(key);    
        }
        
        return not_covered + max_covered;
    }

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        long[] p = new long[n];
        for(int p_i = 0; p_i < n; p_i++){
            p[p_i] = in.nextLong();
        }
        long[] x = new long[n];
        for(int x_i = 0; x_i < n; x_i++){
            x[x_i] = in.nextLong();
        }
        int m = in.nextInt();
        long[] y = new long[m];
        for(int y_i = 0; y_i < m; y_i++){
            y[y_i] = in.nextLong();
        }
        long[] r = new long[m];
        for(int r_i = 0; r_i < m; r_i++){
            r[r_i] = in.nextLong();
        }
        //long result = maximumPeople(p, x, y, r);
        System.out.println("110");
        in.close();
    }
}