import java.util.*;
import java.lang.*;
import java.io.*;
public class Codechef
{       static PrintWriter out=new PrintWriter(System.out);static FastScanner in = new FastScanner(System.in);static class FastScanner {BufferedReader br;StringTokenizer stok;FastScanner(InputStream is) {br = new BufferedReader(new InputStreamReader(is));}
        String next() throws IOException {while (stok == null || !stok.hasMoreTokens()) {String s = br.readLine();if (s == null) {return null;}
                stok = new StringTokenizer(s);}return stok.nextToken();}
        int ni() throws IOException {return Integer.parseInt(next());}long nl() throws IOException {return Long.parseLong(next());}double nd() throws IOException {return Double.parseDouble(next());}char nc() throws IOException {return (char) (br.read());}String ns() throws IOException {return br.readLine();}
        int[] nia(int n) throws IOException{int a[] = new int[n];for (int i = 0; i < n; i++)a[i] = ni();return a;}long[] nla(int n) throws IOException {long a[] = new long[n];for (int i = 0; i < n; i++)a[i] = nl();return a;}
        double[] nda(int n)throws IOException {double a[] = new double[n];for (int i = 0; i < n; i++)a[i] = nd();return a;}int [][] imat(int n,int m) throws IOException{int mat[][]=new int[n][m];for(int i=0;i<n;i++){for(int j=0;j<m;j++)mat[i][j]=ni();}return mat;}
    }
	static long mod=Long.MAX_VALUE;
	public static void main (String[] args) throws java.lang.Exception
	{   int i,j;
	    HashMap<Integer,Integer> hm=new HashMap<Integer,Integer>();
		ArrayList<Integer> arr=new ArrayList<Integer>();
        HashSet<Integer> set=new HashSet<Integer>();
        PriorityQueue<Integer> pq=new PriorityQueue<Integer>();
        int n=in.ni();
        long a[]=in.nla(n);
        long b[]=in.nla(n);
        long temp[]=new long[n];
        for(i=0;i<n;i++)
        {   if(i==0)
                temp[i]=b[i];
            else
                temp[i]=temp[i-1]+b[i];
        }
        ///for(i=0;i<n;i++)
        //    out.print(temp[i]+" ");
        //out.println();
        ArrayList<Integer> index[]=new ArrayList[n+2];
        for(i=0;i<=n;i++)
            index[i]=new ArrayList<Integer>();
        for(i=0;i<n;i++)
        {   long z=temp[i]+a[i];
            if(i!=0)
                z=temp[i-1]+a[i];
            else
                z=a[i];
            int p=binarySearch(temp,z,0,temp.length-1);
            index[p].add(i);
        }
        //for(i=0;i<n;i++)
        //    out.println(index[i]);
        long sum=0;
        for(i=0;i<n;i++)
        {   long ans=0;
            set.add(i);
            long temp2=0;
            //out.println("i="+i);
            for(int c:index[i])
            {   long z=0;
                if(i>0)
                {   z=temp[i-1];
                    //out.println("temp[i-1]="+temp[i-1]);
                }
                //out.println("1:-  "+z);
                if(c>0)
                {   z-=temp[c-1];
                    //out.println("temp[c-1]="+temp[c-1]);
                }
                //out.println("---z="+z);
                //out.println("a[c]="+a[c]);
                z=a[c]-z;
                temp2+=z;
                //out.println("z="+z);
                //if(c!=0)
                //  out.println("----------"+(temp[i]-temp[c-1])+"--"+a[i]);
                //    temp2+=b[i]-(temp[i]-temp[c-1]-a[i]);
                //else
                //    out.println("----------"+(temp[i])+"--"+a[i]);
                //    temp2+=b[i]-(temp[i]-a[i]);
                set.remove(new Integer(c));
                //out.println("*******");
                //temp2+=b[i];
            }
            //out.println("______________________");
            //out.println("i="+i+" temp2="+temp2);
            ans=set.size()*b[i]+temp2;
            out.print(ans+" ");
        }

        out.close();
	}
	static int binarySearch(long a[], long item, int low, int high)
    {   if (high <= low)
            return (item > a[low])?  (low + 1): low;
        int mid = (low + high)/2;
        if(item > a[mid])
            return binarySearch(a, item, mid+1, high);
        return binarySearch(a, item, low, mid-1);
    }
    static void merge(int arr[], int l, int m, int r) {
        int n1 = m - l + 1; int n2 = r - m; int L[] = new int [n1]; int R[] = new int [n2];

        for (int i=0; i<n1; ++i) L[i] = arr[l + i]; for (int j=0; j<n2; ++j) R[j] = arr[m + 1+ j]; int i = 0, j = 0; int k = l; while (i < n1 && j < n2) {   if (L[i] <= R[j]) {   arr[k] = L[i]; i++; } else{   arr[k] = R[j]; j++; } k++; } while (i < n1){   arr[k] = L[i]; i++; k++; } while (j < n2) { arr[k] = R[j];   j++;     k++; }
    }
    static void Sort(int arr[], int l, int r) {if (l < r) {   int m = (l+r)/2; Sort(arr, l, m); Sort(arr , m+1, r); merge(arr, l, m, r); } }

    static void sort(int a[])
    {Sort(a,0,a.length-1);}
}


import java.util.*;
import java.lang.*;
import java.io.*;
public class Codechef
{       static PrintWriter out=new PrintWriter(System.out);static FastScanner in = new FastScanner(System.in);static class FastScanner {BufferedReader br;StringTokenizer stok;FastScanner(InputStream is) {br = new BufferedReader(new InputStreamReader(is));}
        String next() throws IOException {while (stok == null || !stok.hasMoreTokens()) {String s = br.readLine();if (s == null) {return null;}
                stok = new StringTokenizer(s);}return stok.nextToken();}
        int ni() throws IOException {return Integer.parseInt(next());}long nl() throws IOException {return Long.parseLong(next());}double nd() throws IOException {return Double.parseDouble(next());}char nc() throws IOException {return (char) (br.read());}String ns() throws IOException {return br.readLine();}
        int[] nia(int n) throws IOException{int a[] = new int[n];for (int i = 0; i < n; i++)a[i] = ni();return a;}long[] nla(int n) throws IOException {long a[] = new long[n];for (int i = 0; i < n; i++)a[i] = nl();return a;}
        double[] nda(int n)throws IOException {double a[] = new double[n];for (int i = 0; i < n; i++)a[i] = nd();return a;}int [][] imat(int n,int m) throws IOException{int mat[][]=new int[n][m];for(int i=0;i<n;i++){for(int j=0;j<m;j++)mat[i][j]=ni();}return mat;}
    }
	static long mod=Long.MAX_VALUE;
	public static void main (String[] args) throws java.lang.Exception
	{   int i,j;
	    HashMap<Integer,Integer> hm=new HashMap<Integer,Integer>();
		ArrayList<Integer> arr=new ArrayList<Integer>();
        HashSet<Integer> set=new HashSet<Integer>();
        PriorityQueue<Integer> pq=new PriorityQueue<Integer>();
        int n=in.ni();
        long a[]=in.nla(n);
        long b[]=in.nla(n);
        long temp[]=new long[n];
        for(i=0;i<n;i++)
        {   if(i==0)
                temp[i]=b[i];
            else
                temp[i]=temp[i-1]+b[i];
        }
        ///for(i=0;i<n;i++)
        //    out.print(temp[i]+" ");
        //out.println();
        ArrayList<Integer> index[]=new ArrayList[n+2];
        for(i=0;i<=n;i++)
            index[i]=new ArrayList<Integer>();
        for(i=0;i<n;i++)
        {   long z=temp[i]+a[i];
            if(i!=0)
                z=temp[i-1]+a[i];
            else
                z=a[i];
            int p=binarySearch(temp,z,i,temp.length-1);
            index[p].add(i);
        }
        //for(i=0;i<n;i++)
        //    out.println(index[i]);
        long sum=0;
        for(i=0;i<n;i++)
        {   long ans=0;
            set.add(i);
            long temp2=0;
            //out.println("i="+i);
            for(int c:index[i])
            {   long z=0;
                if(i>0)
                {   z=temp[i-1];
                    //out.println("temp[i-1]="+temp[i-1]);
                }
                //out.println("1:-  "+z);
                if(c>0)
                {   z-=temp[c-1];
                    //out.println("temp[c-1]="+temp[c-1]);
                }
                //out.println("---z="+z);
                //out.println("a[c]="+a[c]);
                z=a[c]-z;
                temp2+=z;
                //out.println("z="+z);
                //if(c!=0)
                //  out.println("----------"+(temp[i]-temp[c-1])+"--"+a[i]);
                //    temp2+=b[i]-(temp[i]-temp[c-1]-a[i]);
                //else
                //    out.println("----------"+(temp[i])+"--"+a[i]);
                //    temp2+=b[i]-(temp[i]-a[i]);
                set.remove(new Integer(c));
                //out.println("*******");
                //temp2+=b[i];
            }
            //out.println("______________________");
            //out.println("i="+i+" temp2="+temp2);
            ans=set.size()*b[i]+temp2;
            out.print(ans+" ");
        }

        out.close();
	}
	static int binarySearch(long a[], long item, int low, int high)
    {   if (high <= low)
            return (item > a[low])?  (low + 1): low;
        int mid = (low + high)/2;
        if(item > a[mid])
            return binarySearch(a, item, mid+1, high);
        return binarySearch(a, item, low, mid-1);
    }
    static void merge(int arr[], int l, int m, int r) {
        int n1 = m - l + 1; int n2 = r - m; int L[] = new int [n1]; int R[] = new int [n2];

        for (int i=0; i<n1; ++i) L[i] = arr[l + i]; for (int j=0; j<n2; ++j) R[j] = arr[m + 1+ j]; int i = 0, j = 0; int k = l; while (i < n1 && j < n2) {   if (L[i] <= R[j]) {   arr[k] = L[i]; i++; } else{   arr[k] = R[j]; j++; } k++; } while (i < n1){   arr[k] = L[i]; i++; k++; } while (j < n2) { arr[k] = R[j];   j++;     k++; }
    }
    static void Sort(int arr[], int l, int r) {if (l < r) {   int m = (l+r)/2; Sort(arr, l, m); Sort(arr , m+1, r); merge(arr, l, m, r); } }

    static void sort(int a[])
    {Sort(a,0,a.length-1);}
}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.StringTokenizer;

public class Main {
	private static int N;
	private static long[] snows, days, sums, deltas, remainders;

	public static void main(String[] args) throws IOException {
		BufferedReader f = new BufferedReader(new InputStreamReader(System.in));
		N = Integer.parseInt(f.readLine());
		snows = new long[N];
		days = new long[N];
		sums = new long[N + 1];
		deltas = new long[N + 1];
		remainders = new long[N + 1];
		StringTokenizer st = new StringTokenizer(f.readLine());
		for (int i = 0; i < N; i++) {
			snows[i] = Long.parseLong(st.nextToken());
		}
		st = new StringTokenizer(f.readLine());
		for (int i = 0; i < N; i++) {
			days[i] = Long.parseLong(st.nextToken());
		}
		for (int i = 1; i <= N; i++) {
			sums[i] = sums[i - 1] + days[i - 1];
		}
		for (int i = 0; i < N; i++) {
			deltas[i]++;
			long search = snows[i] + sums[i];
			int meltIndex = Arrays.binarySearch(sums, search);
			if (meltIndex < 0)
				meltIndex = -meltIndex - 1;
			meltIndex--;
			if (meltIndex == -1) {
				meltIndex = 0;
			}
			if (meltIndex == N) {
				continue;
			}
			long remainder = search - sums[meltIndex];
			deltas[meltIndex]--;
			remainders[meltIndex] += remainder;
		}
		StringBuilder sb = new StringBuilder();
		int amount = 0;
		for (int i = 0; i < N; i++) {
			amount += deltas[i];
			sb.append(amount * days[i] + remainders[i]).append(" ");
		}
		System.out.println(sb.toString());
	}
}

//comment


//package codecheff;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;

public class binarymove {
	public static long[] Ti;
	public static int V;
	public binarymove( int v) {
		V = v;
		Ti = new long[v];
	}

	public static int binarySearch(long x)
    {
        int l = 0, r = V - 1;
        while (l <= r) {
            int m = l + (r - l) / 2;
           // System.out.println(m+" "+x);
            if (Ti[m] >= x & Ti[m-1]<x)
                return m;

            if (Ti[m] < x)
                l = m + 1;

            else
                r = m - 1;
        }

        return -1;
    }

	public static void main(String[] args) throws NumberFormatException, IOException {

		InputStreamReader is = new InputStreamReader(System.in);
		BufferedReader br = new BufferedReader(is);
		int n = Integer.parseInt(br.readLine());
		String[] ab = br.readLine().split(" ");
		String[] cd = br.readLine().split(" ");
		long[] Vi = new long[n+1];
		binarymove bu = new binarymove(n+1);
		for(int i =1;i<n+1;i++) {
			Vi[i] = Integer.parseInt(ab[i-1]);
			Ti[i] = Integer.parseInt(cd[i-1])+Ti[i-1];
		}
		long[] arr = new long[n+1];
		long[] starting = new long[n+1];
		long[] ans = new long[n+1];
		int index = 0;
 		for(int i =1;i<=n;i++) {
 			if(i==n) {
 				if(Vi[i]>=Ti[n]-Ti[n-1]) {
 					ans[n] +=Ti[n]-Ti[n-1];
 				}else {
 					ans[n]+=Vi[n];
 				}
 			}
 			else if(Vi[i]+Ti[i-1]>=Ti[n]) {
 				arr[n-1]+=1;
 				ans[n]+=Ti[n]-Ti[n-1];
 				starting[i] = 1;
 			}
 			else if(Vi[i]>Ti[i]-Ti[i-1]) {
 				index =  binarySearch(Vi[i]+Ti[i-1]);
 				//System.out.println(index+" index");
 				starting[i] = 1;
 				arr[index-1] +=1;
 				ans[index]+=Vi[i]-Ti[index-1]+Ti[i-1];
 			}
 			else {
 				ans[i]+=Vi[i];
 			}
		}
 		int innu = 0;

 		for(int i =1;i<n;i++) {
 			if(starting[i]==1) {
 				innu++;
 			}
 			ans[i]+=innu*(Ti[i]-Ti[i-1]);
 			innu-=arr[i];

 		}
 		StringBuffer sb = new StringBuffer();
 		for(int i =1;i<n;i++) {
 			sb.append(ans[i]+" ");
 		}
 		sb.append(ans[n]);
 		System.out.println(sb);
	}
}


//package codecheff;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;

public class binarymove {
	public static long[] Ti;
	public static int V;
	public binarymove( int v) {
		V = v;
		Ti = new long[v];
	}

	public static int binarySearch(long x)
    {
        int l = 0, r = V - 1;
        while (l <= r) {
            int m = l + (r - l) / 2;
           // System.out.println(m+" "+x);
            if (Ti[m] >= x & Ti[m-1]<x)
                return m;

            if (Ti[m] < x)
                l = m + 1;

            else
                r = m - 1;
        }

        return -1;
    }

	public static void main(String[] args) throws NumberFormatException, IOException {

		InputStreamReader is = new InputStreamReader(System.in);
		BufferedReader br = new BufferedReader(is);
		int n = Integer.parseInt(br.readLine());
		String[] ab = br.readLine().split(" ");
		String[] cd = br.readLine().split(" ");
		long[] Vi = new long[n+1];
		binarymove bu = new binarymove(n+1);
		for(int i =1;i<n+1;i++) {
			Vi[i] = Integer.parseInt(ab[i-1]);
			Ti[i] = Integer.parseInt(cd[i-1])+Ti[i-1];
		}
		long[] arr = new long[n+1];
		long[] ans = new long[n+1];
		int index = 0;
 		for(int i =1;i<=n;i++) {
 			if(i==n) {
 				if(Vi[i]>=Ti[n]-Ti[n-1]) {
 					ans[n] +=Ti[n]-Ti[n-1];
 				}else {
 					ans[n]+=Vi[n];
 				}
 			}
 			else if(Vi[i]+Ti[i-1]>=Ti[n]) {
 				arr[n-1]+=1;
 				ans[n]+=Ti[n]-Ti[n-1];
 			}
 			else if(Vi[i]>Ti[i]-Ti[i-1]) {
 				index =  binarySearch(Vi[i]+Ti[i-1]);
 				//System.out.println(index+" index");
 				arr[index-1] +=1;
 				ans[index]+=Vi[i]-Ti[index-1]+Ti[i-1];
 			}
 			else {
 				ans[i]+=Vi[i];
 			}
		}
 		int innu = 0;

 		for(int i =1;i<n;i++) {
 			innu++;
 			ans[i]+=innu*(Ti[i]-Ti[i-1]);
 			innu-=arr[i];

 		}
 		StringBuffer sb = new StringBuffer();
 		for(int i =1;i<n;i++) {
 			sb.append(ans[i]+" ");
 		}
 		sb.append(ans[n]);
 		System.out.println(sb);
	}
}


import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.FileNotFoundException;
import java.util.StringTokenizer;
import java.io.Writer;
import java.io.BufferedReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author Asgar Javadov
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);
        TaskC solver = new TaskC();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskC {
        public void solve(int testNumber, InputReader in, OutputWriter out) {
            int n = in.nextInt();
            int[] v = in.readIntArray(n);
            int[] t = in.readIntArray(n);

//        LazyPropagation tree = new LazyPropagation(n, (a, b) -> a + b, 0L);
            LazyPropagationSum tree = new LazyPropagationSum(n);

            long[] cum = ArrayUtils.partialSum(t);

            int[] cnt = new int[n];
            long[] rem = new long[n];
            long prev = 0L;
            for (int i = 0; i < n; ++i) {
                int pos = ArrayUtils.lowerBound(cum, v[i] + prev);

//            ++cnt[i];
//            if (pos < n) --cnt[pos];

                tree.update(i, pos - 1, 1);
                if (pos < n) {
                    rem[pos] += v[i] + prev;
                    if (pos > 0)
                        rem[pos] -= cum[pos - 1];
                }

                prev = cum[i];
            }

            long wholeCount = 0;
            for (int i = 0; i < n; ++i) {
                if (i > 0) out.print(' ');
//            wholeCount += cnt[i];
                wholeCount = tree.get(i, i);
                long res = wholeCount * t[i] + rem[i];
                out.print(res);
            }
            out.println();

        }

    }

    static class ArrayUtils {
        public static int lowerBound(long[] array, long val) {
            int low = 0, high = array.length - 1;
            while (low <= high) {
                int mid = (low + high) >> 1;
                if (val < array[mid]) high = mid - 1;
                else low = mid + 1;
            }
            return low;
        }

        public static long[] partialSum(int... args) {
            long[] result = new long[args.length];

            result[0] = (long) args[0];
            for (int i = 1; i < args.length; ++i)
                result[i] = result[i - 1] + args[i];

            return result;
        }

    }

    static class LazyPropagationSum {
        private int n;
        private long[] tree;
        private long[] lazy;

        public LazyPropagationSum(int length) {
            this.n = length - 1;
            int size = Integer.highestOneBit(length) << 2;
            this.tree = new long[size];
            this.lazy = new long[size];
        }

        public LazyPropagationSum(int[] arr) {
            this(arr.length);

            build(1, 0, n, arr);
        }

        private void build(int node, int l, int r, int[] arr) {
            if (l >= r) {
                this.tree[node] = arr[l];
                this.lazy[node] = 0L;
                return;
            }

            int mid = l + r >> 1;
            int leftSon = node << 1;
            int rightSon = leftSon | 1;

            build(leftSon, l, mid, arr);
            build(rightSon, mid + 1, r, arr);

            this.tree[node] = tree[leftSon] + tree[rightSon];
            this.lazy[node] = 0L;
        }

        public long get(int qs, int qe) {
            return get(1, 0, n, qs, qe);
        }

        private long get(int node, int l, int r, int qs, int qe) {
            if (lazy[node] != 0L)
                propagate(node, l, r);

            if (qe < l || r < qs || l > r)
                return 0L;

            if (qs <= l && r <= qe)
                return tree[node];

            int mid = l + r >> 1;
            int leftSon = node << 1;
            int rightSon = leftSon | 1;

            return get(leftSon, l, mid, qs, qe) + get(rightSon, mid + 1, r, qs, qe);
        }

        public void update(int qs, int qe, int value) {
            update(1, 0, n, qs, qe, value);
        }

        private void update(int node, int l, int r, int qs, int qe, int value) {
            if (lazy[node] != 0L)
                propagate(node, l, r);

            if (qe < l || r < qs || r < l)
                return;

            if (qs <= l && r <= qe) {
                lazy[node] += value;
                propagate(node, l, r);
                return;
            }

            int mid = l + r >> 1;
            int leftSon = node << 1;
            int rightSon = leftSon | 1;

            update(leftSon, l, mid, qs, qe, value);
            update(rightSon, mid + 1, r, qs, qe, value);

            tree[node] = tree[leftSon] + tree[rightSon];
        }

        private void propagate(int node, int l, int r) {
            tree[node] += (r - l + 1) * lazy[node];
            if (l != r) {
                int leftSon = node << 1;
                int rightSon = leftSon | 1;
                lazy[leftSon] += lazy[node];
                lazy[rightSon] += lazy[node];
            }

            lazy[node] = 0L;
        }

    }

    static class OutputWriter extends PrintWriter {
        public OutputWriter(OutputStream outputStream) {
            super(outputStream);
        }

        public OutputWriter(Writer writer) {
            super(writer);
        }

        public OutputWriter(String filename) throws FileNotFoundException {
            super(filename);
        }

        public void close() {
            super.close();
        }

    }

    static class InputReader extends BufferedReader {
        StringTokenizer tokenizer;

        public InputReader(InputStream inputStream) {
            super(new InputStreamReader(inputStream), 32768);
        }

        public InputReader(String filename) {
            super(new InputStreamReader(Thread.currentThread().getContextClassLoader().getResourceAsStream(filename)));
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(readLine());
                } catch (IOException e) {
                    throw new RuntimeException();
                }
            }
            return tokenizer.nextToken();
        }

        public Integer nextInt() {
            return Integer.valueOf(next());
        }

        public int[] readIntArray(int size) {
            int[] array = new int[size];
            for (int i = 0; i < size; i++)
                array[i] = nextInt();
            return array;
        }

    }
}


import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.FileNotFoundException;
import java.util.StringTokenizer;
import java.io.Writer;
import java.io.BufferedReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author Asgar Javadov
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);
        TaskC solver = new TaskC();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskC {
        public void solve(int testNumber, InputReader in, OutputWriter out) {
            int n = in.nextInt();
            int[] v = in.readIntArray(n);
            int[] t = in.readIntArray(n);

//        LazyPropagation tree = new LazyPropagation(n, (a, b) -> a + b, 0L);

            long[] cum = ArrayUtils.partialSum(t);

            int[] cnt = new int[n];
            long[] rem = new long[n];
            long prev = 0L;
            for (int i = 0; i < n; ++i) {
                int pos = ArrayUtils.lowerBound(cum, v[i] + prev);
                ++cnt[i];
                if (pos < n) --cnt[pos];

//            tree.updateRange(i, pos - 1, 1);
                if (pos < n) {
                    rem[pos] += v[i] + prev;
                    if (pos > 0)
                        rem[pos] -= cum[pos - 1];
                }

                prev = cum[i];
            }

            long wholeCount = 0;
            for (int i = 0; i < n; ++i) {
                if (i > 0) out.print(' ');
                wholeCount += cnt[i];
                long res = wholeCount * t[i] + rem[i];
                out.print(res);
            }
            out.println();

        }

    }

    static class ArrayUtils {
        public static int lowerBound(long[] array, long val) {
            int low = 0, high = array.length - 1;
            while (low <= high) {
                int mid = (low + high) >> 1;
                if (val < array[mid]) high = mid - 1;
                else low = mid + 1;
            }
            return low;
        }

        public static long[] partialSum(int... args) {
            long[] result = new long[args.length];

            result[0] = (long) args[0];
            for (int i = 1; i < args.length; ++i)
                result[i] = result[i - 1] + args[i];

            return result;
        }

    }

    static class InputReader extends BufferedReader {
        StringTokenizer tokenizer;

        public InputReader(InputStream inputStream) {
            super(new InputStreamReader(inputStream), 32768);
        }

        public InputReader(String filename) {
            super(new InputStreamReader(Thread.currentThread().getContextClassLoader().getResourceAsStream(filename)));
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(readLine());
                } catch (IOException e) {
                    throw new RuntimeException();
                }
            }
            return tokenizer.nextToken();
        }

        public Integer nextInt() {
            return Integer.valueOf(next());
        }

        public int[] readIntArray(int size) {
            int[] array = new int[size];
            for (int i = 0; i < size; i++)
                array[i] = nextInt();
            return array;
        }

    }

    static class OutputWriter extends PrintWriter {
        public OutputWriter(OutputStream outputStream) {
            super(outputStream);
        }

        public OutputWriter(Writer writer) {
            super(writer);
        }

        public OutputWriter(String filename) throws FileNotFoundException {
            super(filename);
        }

        public void close() {
            super.close();
        }

    }
}


// package CF;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.StringTokenizer;

public class B {

	public static void main(String[] args) throws Exception {
		Scanner sc = new Scanner(System.in);
		PrintWriter out = new PrintWriter(System.out);
		int n = sc.nextInt();
		int [] v = new int[n];
		long [] t = new long[n];
		long [] num = new long[n];
		long [] mod = new long[n];
		for (int i = 0; i < v.length; i++) {
			v[i] = sc.nextInt();
		}
		for (int i = 0; i < v.length; i++) {
			t[i] = sc.nextInt();
			if(i > 0)
				t[i] += t[i-1];
		}
		for (int i = 0; i < num.length; i++) {
			long tmp = v[i]+(i-1<0?0:t[i-1]);
			int lo = i, hi = n-1, ans = -1;
			while(lo <= hi){
				int mid = (lo + hi)/2;
				if(t[mid] >= tmp){
					ans = mid;
					hi = mid-1;
				}
				else{
					lo = mid+1;
				}
			}
			num[i]++;
//			System.out.println(ans);
			if(ans != -1)
			{
				if(t[ans] == tmp)
					ans++;
				else{
					mod[ans] += Math.max(0, tmp-(ans == 0?0:t[ans-1]));
				}
				if(ans < n)
					num[ans]--;
			}
		}
		for (int i = 1; i < num.length; i++) {
			num[i] += num[i-1];
		}
		for (int i = 0; i < num.length; i++) {
			out.print(num[i]*(t[i]-(i-1<0?0:t[i-1]))+mod[i] + " ");
		}
		out.flush();
		out.close();
	}
	static class Scanner {
		StringTokenizer st;
		BufferedReader br;

		public Scanner(InputStream s) {
			br = new BufferedReader(new InputStreamReader(s));
		}

		public Scanner(FileReader fileReader) {
			br = new BufferedReader(fileReader);
		}

		public String next() throws IOException {
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}

		public int nextInt() throws IOException {
			return Integer.parseInt(next());
		}

		public long nextLong() throws IOException {
			return Long.parseLong(next());
		}

		public String nextLine() throws IOException {
			return br.readLine();
		}

		public boolean ready() throws IOException {
			return br.ready();
		}
	}
}


import java.util.*;
import java.lang.*;
import java.io.*;
import java.math.*;

public class CF923B {

	static class FastScanner {
	    private InputStream stream;
	    private byte[] buf = new byte[1024];
	    private int curChar;
	    private int numChars;
	    private SpaceCharFilter filter;

	    public FastScanner(InputStream stream) {
	        this.stream = stream;
	    }

	    public static boolean isWhitespace(int c) {
	        return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
	    }

	    public int read() {
	        if (numChars == -1)
	            throw new InputMismatchException();
	        if (curChar >= numChars) {
	            curChar = 0;
	            try {
	                numChars = stream.read(buf);
	            } catch (IOException e) {
	                throw new InputMismatchException();
	            }
	            if (numChars <= 0)
	                return -1;
	        }
	        return buf[curChar++];
	    }

	    public int nextInt() {
	        int c = read();
	        while (isSpaceChar(c))
	            c = read();
	        int sgn = 1;
	        if (c == '-') {
	            sgn = -1;
	            c = read();
	        }
	        int res = 0;
	        do {
	            if (c < '0' || c > '9')
	                throw new InputMismatchException();
	            res *= 10;
	            res += c - '0';
	            c = read();
	        } while (!isSpaceChar(c));
	        return res * sgn;
	    }

	    public long nextLong() {
	        int c = read();
	        while (isSpaceChar(c))
	            c = read();
	        int sgn = 1;
	        if (c == '-') {
	            sgn = -1;
	            c = read();
	        }
	        long res = 0;
	        do {
	            if (c < '0' || c > '9')
	                throw new InputMismatchException();
	            res *= 10;
	            res += c - '0';
	            c = read();
	        } while (!isSpaceChar(c));
	        return res * sgn;
	    }

	    public String nextToken() {
	        int c = read();
	        while (isSpaceChar(c))
	            c = read();
	        StringBuilder res = new StringBuilder();
	        do {
	            res.appendCodePoint(c);
	            c = read();
	        } while (!isSpaceChar(c));
	        return res.toString();
	    }

	    public boolean isSpaceChar(int c) {
	        if (filter != null)
	            return filter.isSpaceChar(c);
	        return isWhitespace(c);
	    }

	    public interface SpaceCharFilter {
	        public boolean isSpaceChar(int ch);
	    }
	}

    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
	static PrintWriter pw = new PrintWriter(new OutputStreamWriter(System.out));

	public static void main(String[] args) throws Exception {
		FastScanner fs = new FastScanner(System.in);
		int n = fs.nextInt();
		long[] v = new long[n], t = new long[n], ft = new long[n+1], vprime = new long[n], meltOn = new long[n];
		for(int i=0; i<n; i++)
			v[i] = fs.nextLong();
		for(int i=0; i<n; i++)
			t[i] = fs.nextLong();
		for(int i=1; i<=n; i++)
			ft[i] = ft[i-1]+ t[i-1];

		PriorityQueue<Long> pq = new PriorityQueue<>();
		vprime[0] = v[0];
		for(int i=1; i<n; i++)
			vprime[i] = ft[i] + v[i];

		for(int i=0; i<n; i++) {
			long d = 0;
			pq.add((long) vprime[i]);
			while(!pq.isEmpty() && pq.peek() <= ft[i+1])
				d += pq.remove() - ft[i];

			d += pq.size() * t[i];
			meltOn[i] = d;
		}

		for(int i=0; i<n; i++) {
			pw.print(meltOn[i] + " ");
		}
		pw.flush();
		pw.close();
	}

}


import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.ByteArrayOutputStream;
import java.util.Iterator;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.FileNotFoundException;
import java.io.File;
import java.util.TreeSet;
import java.util.StringTokenizer;
import java.io.Writer;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
  public static void main(String[] args) {
    InputStream inputStream = System.in;
    OutputStream outputStream = System.out;
    InputReader in = new InputReader(inputStream);
    OutputWriter out = new OutputWriter(outputStream);
    TaskB solver = new TaskB();
    solver.solve(1, in, out);
    out.close();
  }

  static class TaskB extends SimpleSavingChelperSolution {
    public void solve(int testNumber, InputReader in, OutputWriter out) {
      wrapSolve(testNumber, in, out);
    }

    public void solve(int testNumber) {
      int n = in.nextInt();

      TreeSet<Long> set = new TreeSet<>();

      long[] v = in.nextLongArray(n);
      long[] t = in.nextLongArray(n);

      long corr = 0;

      for (int i = 0; i < n; i++) {
        long res = 0;

        set.add(v[i] + corr);

        Iterator<Long> iterator = set.iterator();
        while (iterator.hasNext()) {
          long x = iterator.next() - corr;

          if (x <= t[i]) {
            res += x;
            iterator.remove();
          } else {
            break;
          }

        }

        res += set.size() * t[i];

        corr += t[i];

        out.print(res + " ");
      }
    }

  }

  static class OutputWriter extends PrintWriter {

    public void close() {
      super.close();
    }

    public OutputWriter(String fileName) throws FileNotFoundException {
      super(fileName);
    }

    public OutputWriter(OutputStream outputStream) {
      super(outputStream);
    }

    public OutputWriter(Writer writer) {
      super(writer);
    }

  }

  static abstract class SavingChelperSolution {
    protected int testNumber;
    public InputReader in;
    public OutputWriter out;
    private OutputWriter toFile;
    private boolean local = new File("chelper.properties").exists();
    public OutputWriter debug;

    {
      if (local) {
        debug = new OutputWriter(System.err);
      } else {
        debug = new OutputWriter(new OutputStream() {

          public void write(int b) {
          }
        });
      }
    }

    public SavingChelperSolution() {
      try {
        toFile = new OutputWriter("last_test_output.txt");
      } catch (FileNotFoundException e) {
        throw new RuntimeException(e);
      }
    }

    public abstract void solve(int testNumber);

    public abstract String processOutputPreCheck(int testNumber, String output);

    public abstract String processOutputPostCheck(int testNumber, String output);

    public void wrapSolve(int testNumber, InputReader in, OutputWriter out) {
      this.testNumber = testNumber;

      ByteArrayOutputStream substituteOutContents = new ByteArrayOutputStream();
      OutputWriter substituteOut = new OutputWriter(substituteOutContents);

      this.in = in;
      this.out = substituteOut;

      solve(testNumber);
      substituteOut.flush();

      String result = substituteOutContents.toString();

      result = processOutputPreCheck(testNumber, result);
      out.print(result);
      out.flush();

      if (local) {
        debug.flush();

        result = processOutputPostCheck(testNumber, result);
        toFile.print(result);
        toFile.flush();
      }
    }

  }

  static abstract class SimpleSavingChelperSolution extends SavingChelperSolution {

    public String processOutputPreCheck(int testNumber, String output) {
      return output;
    }

    public String processOutputPostCheck(int testNumber, String output) {
      return output;
    }

  }

  static class InputReader {
    private BufferedReader br;
    private StringTokenizer in;

    public InputReader(String fileName) {
      try {
        br = new BufferedReader(new FileReader(fileName));
      } catch (IOException e) {
        throw new RuntimeException(e);
      }
    }

    public InputReader(InputStream inputStream) {
      br = new BufferedReader(new InputStreamReader(inputStream));
    }

    private boolean hasMoreTokens() {
      while (in == null || !in.hasMoreTokens()) {
        String s = nextLine();
        if (s == null) {
          return false;
        }
        in = new StringTokenizer(s);
      }
      return true;
    }

    public String nextString() {
      return hasMoreTokens() ? in.nextToken() : null;
    }

    public String nextLine() {
      try {
        in = null;
        return br.readLine();
      } catch (Exception e) {
        e.printStackTrace();
        return null;
      }
    }

    public int nextInt() {
      return Integer.parseInt(nextString());
    }

    public long nextLong() {
      return Long.parseLong(nextString());
    }

    public long[] nextLongArray(int n) {
      long[] a = new long[n];
      for (int i = 0; i < n; i++) {
        a[i] = nextLong();
      }
      return a;
    }

  }
}


import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.ByteArrayOutputStream;
import java.util.TreeSet;
import java.util.StringTokenizer;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.Iterator;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.FileNotFoundException;
import java.io.File;
import java.util.Objects;
import java.io.Writer;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
  public static void main(String[] args) {
    InputStream inputStream = System.in;
    OutputStream outputStream = System.out;
    InputReader in = new InputReader(inputStream);
    OutputWriter out = new OutputWriter(outputStream);
    TaskB solver = new TaskB();
    solver.solve(1, in, out);
    out.close();
  }

  static class TaskB extends SimpleSavingChelperSolution {
    public void solve(int testNumber, InputReader in, OutputWriter out) {
      wrapSolve(testNumber, in, out);
    }

    public void solve(int testNumber) {
      int n = in.nextInt();

      TreeSet<MultiLong> set = new TreeSet<>();

      long[] v = in.nextLongArray(n);
      long[] t = in.nextLongArray(n);

      long corr = 0;

      for (int i = 0; i < n; i++) {
        long res = 0;

        set.add(new MultiLong(i, v[i] + corr));

        Iterator<MultiLong> iterator = set.iterator();
        while (iterator.hasNext()) {
          long x = iterator.next().x - corr;

          if (x <= t[i]) {
            res += x;
            iterator.remove();
          } else {
            break;
          }

        }

        res += set.size() * t[i];

        corr += t[i];

        out.print(res + " ");
      }
    }

    class MultiLong implements Comparable<MultiLong> {
      long i;
      long x;

      public MultiLong(long i, long x) {
        this.i = i;
        this.x = x;
      }

      public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        MultiLong multiLong = (MultiLong) o;
        return i == multiLong.i &&
            x == multiLong.x;
      }

      public int hashCode() {

        return Objects.hash(i, x);
      }

      public int compareTo(MultiLong o) {
        int t = Long.compare(x, o.x);
        if (t != 0) {
          return t;
        }

        return Long.compare(i, o.i);
      }

    }

  }

  static class OutputWriter extends PrintWriter {

    public void close() {
      super.close();
    }

    public OutputWriter(String fileName) throws FileNotFoundException {
      super(fileName);
    }

    public OutputWriter(OutputStream outputStream) {
      super(outputStream);
    }

    public OutputWriter(Writer writer) {
      super(writer);
    }

  }

  static abstract class SavingChelperSolution {
    protected int testNumber;
    public InputReader in;
    public OutputWriter out;
    private OutputWriter toFile;
    private boolean local = new File("chelper.properties").exists();
    public OutputWriter debug;

    {
      if (local) {
        debug = new OutputWriter(System.err);
      } else {
        debug = new OutputWriter(new OutputStream() {

          public void write(int b) {
          }
        });
      }
    }

    public SavingChelperSolution() {
      try {
        toFile = new OutputWriter("last_test_output.txt");
      } catch (FileNotFoundException e) {
        throw new RuntimeException(e);
      }
    }

    public abstract void solve(int testNumber);

    public abstract String processOutputPreCheck(int testNumber, String output);

    public abstract String processOutputPostCheck(int testNumber, String output);

    public void wrapSolve(int testNumber, InputReader in, OutputWriter out) {
      this.testNumber = testNumber;

      ByteArrayOutputStream substituteOutContents = new ByteArrayOutputStream();
      OutputWriter substituteOut = new OutputWriter(substituteOutContents);

      this.in = in;
      this.out = substituteOut;

      solve(testNumber);
      substituteOut.flush();

      String result = substituteOutContents.toString();

      result = processOutputPreCheck(testNumber, result);
      out.print(result);
      out.flush();

      if (local) {
        debug.flush();

        result = processOutputPostCheck(testNumber, result);
        toFile.print(result);
        toFile.flush();
      }
    }

  }

  static abstract class SimpleSavingChelperSolution extends SavingChelperSolution {

    public String processOutputPreCheck(int testNumber, String output) {
      return output;
    }

    public String processOutputPostCheck(int testNumber, String output) {
      return output;
    }

  }

  static class InputReader {
    private BufferedReader br;
    private StringTokenizer in;

    public InputReader(String fileName) {
      try {
        br = new BufferedReader(new FileReader(fileName));
      } catch (IOException e) {
        throw new RuntimeException(e);
      }
    }

    public InputReader(InputStream inputStream) {
      br = new BufferedReader(new InputStreamReader(inputStream));
    }

    private boolean hasMoreTokens() {
      while (in == null || !in.hasMoreTokens()) {
        String s = nextLine();
        if (s == null) {
          return false;
        }
        in = new StringTokenizer(s);
      }
      return true;
    }

    public String nextString() {
      return hasMoreTokens() ? in.nextToken() : null;
    }

    public String nextLine() {
      try {
        in = null;
        return br.readLine();
      } catch (Exception e) {
        e.printStackTrace();
        return null;
      }
    }

    public int nextInt() {
      return Integer.parseInt(nextString());
    }

    public long nextLong() {
      return Long.parseLong(nextString());
    }

    public long[] nextLongArray(int n) {
      long[] a = new long[n];
      for (int i = 0; i < n; i++) {
        a[i] = nextLong();
      }
      return a;
    }

  }
}


import java.io.*;
import java.util.PriorityQueue;
import java.util.StringTokenizer;

public class CFR {

    public static void main(String[] args) throws IOException {
        Scanner sc = new Scanner(System.in);
        PrintWriter out = new PrintWriter(System.out);
        int n = sc.nextInt();
        int[] snow = new int[n];
        int[] temp = new int[n];
        for (int i = 0; i < n; i++)
            snow[i] = sc.nextInt();
        for (int j = 0; j < n; j++)
            temp[j] = sc.nextInt();
        long cum = 0;
        PriorityQueue<Long> pq = new PriorityQueue<>();
        for (int i = 0; i < n; i++) {
            long tot = 0;
            pq.add(snow[i] + cum);
            while (!pq.isEmpty() && pq.peek() - cum <= temp[i])
                tot += (pq.remove() - cum);
            out.print(1l*pq.size() * temp[i] + tot + " ");
            cum += temp[i];
        }
        out.flush();
        out.close();
    }

    static class Scanner {

        BufferedReader br;
        StringTokenizer st;

        Scanner(InputStream system) {
            br = new BufferedReader(new InputStreamReader(system));
        }

        String next() throws IOException {
            while (st == null || !st.hasMoreTokens())
                st = new StringTokenizer(br.readLine());
            return st.nextToken();
        }

        int nextInt() throws IOException {
            return Integer.parseInt(next());
        }

        double nextDouble() throws IOException {
            return Double.parseDouble(next());
        }

        long nextLong() throws IOException {
            return Long.parseLong(next());
        }

    }

}


import java.io.*;
import java.util.PriorityQueue;
import java.util.StringTokenizer;

public class CFR {

    public static void main(String[] args) throws IOException {
        Scanner sc = new Scanner(System.in);
        PrintWriter out = new PrintWriter(System.out);
        int n = sc.nextInt();
        int[] snow = new int[n];
        int[] temp = new int[n];
        for (int i = 0; i < n; i++)
            snow[i] = sc.nextInt();
        for (int j = 0; j < n; j++)
            temp[j] = sc.nextInt();
        int cum = 0;
        PriorityQueue<Integer> pq = new PriorityQueue<>();
        for (int i = 0; i < n; i++) {
            int tot = 0;
            pq.add(snow[i] + cum);
            while (!pq.isEmpty() && pq.peek() - cum <= temp[i])
                tot += (pq.remove() - cum);
            out.print(pq.size() * temp[i] + tot + " ");
            cum += temp[i];
        }
        out.flush();
        out.close();
    }

    static class Scanner {

        BufferedReader br;
        StringTokenizer st;

        Scanner(InputStream system) {
            br = new BufferedReader(new InputStreamReader(system));
        }

        String next() throws IOException {
            while (st == null || !st.hasMoreTokens())
                st = new StringTokenizer(br.readLine());
            return st.nextToken();
        }

        int nextInt() throws IOException {
            return Integer.parseInt(next());
        }

        double nextDouble() throws IOException {
            return Double.parseDouble(next());
        }

        long nextLong() throws IOException {
            return Long.parseLong(next());
        }

    }

}


import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class probB {
    class FastScanner {
        private BufferedReader reader;
        private StringTokenizer tokenizer;

        public FastScanner(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream));
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

        public long nextLong() {
            return Long.parseLong(next());
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

        public double nextDouble() {
            return Double.parseDouble(next());
        }
    }

    public void run() throws FileNotFoundException {
        FastScanner in = new FastScanner(System.in);
        PrintWriter out = new PrintWriter(System.out);

        //FastScanner in = new FastScanner(new FileInputStream("input.txt"));
        //PrintWriter out = new PrintWriter("output.txt");

        int n = in.nextInt();
        long[] v = new long[n + 10];
        long[] t = new long[n + 10];
        long[] res = new long[n + 10];

        int[] start = new int[n + 10];
        int[] finish = new int[n + 10];

        for (int i = 0; i < n; i++) {
            v[i] = in.nextInt();

            start[i] = 0;
            finish[i] = 0;
        }

        for (int i = 0; i < n; i++) {
            t[i] = in.nextInt();
            if (i > 0) {
                t[i] = t[i] + t[i - 1];
            }

            res[i] = 0;
        }

        for (int i = 0; i < n; i++) {
            int l = i - 1;
            int r = n;

            long before_v = 0;
            if (i > 0) {
                before_v = t[i - 1];
            }

            while (r - l > 1) {
                int m = (r + l) / 2;
                if (t[m] - before_v >= v[i]) {
                    r = m;
                } else {
                    l = m;
                }
            }

            // в день r точно расстает
            // => будет таять со дня i до дня r
            if (r < n) {
                long before_r = 0;
                if (r > 0) {
                    before_r = t[r - 1] - before_v;
                }
                res[r] += v[i] - before_r;
            }

            if (r > i) {
                start[i] += 1;
                finish[r] += 1;
            }

        }

        int cur = 0;
        for (int i = 0; i < n; i++) {
            cur += start[i];
            cur -= finish[i];

            long x;
            if (i == 0) {
                x = t[i];
            } else {
                x = t[i] - t[i - 1];
            }

            res[i] += x * cur;

            out.print(res[i]);
            out.print(" ");
        }

        out.close();
    }

    public static void main(String[] args) throws FileNotFoundException {
        new probB().run();
    }
}


import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class probB {
    class FastScanner {
        private BufferedReader reader;
        private StringTokenizer tokenizer;

        public FastScanner(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream));
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

        public long nextLong() {
            return Long.parseLong(next());
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

        public double nextDouble() {
            return Double.parseDouble(next());
        }
    }

    public void run() throws FileNotFoundException {
        FastScanner in = new FastScanner(System.in);
        PrintWriter out = new PrintWriter(System.out);

        //FastScanner in = new FastScanner(new FileInputStream("input.txt"));
        //PrintWriter out = new PrintWriter("output.txt");

        int n = in.nextInt();
        long[] v = new long[n + 10];
        long[] t = new long[n + 10];
        long[] res = new long[n + 10];

        int[] start = new int[n + 10];
        int[] finish = new int[n + 10];

        for (int i = 0; i < n; i++) {
            v[i] = in.nextInt();

            start[i] = 0;
            finish[i] = 0;
        }

        for (int i = 0; i < n; i++) {
            t[i] = in.nextInt();
            if (i > 0) {
                t[i] = t[i] + t[i - 1];
            }

            res[i] = 0;
        }

        for (int i = 0; i < n; i++) {
            int l = 0;
            int r = n;

            long before_v = 0;
            if (i > 0) {
                before_v = t[i - 1];
            }

            while (r - l > 1) {
                int m = (r + l) / 2;
                if (t[m] - before_v >= v[i]) {
                    r = m;
                } else {
                    l = m;
                }
            }

            // в день r точно расстает
            // => будет таять со дня i до дня r
            if (r < n) {
                long before_r = 0;
                if (r > 0) {
                    before_r = t[r - 1] - before_v;
                }
                res[r] += v[i] - before_r;
            }

            if (r > i) {
                start[i] += 1;
                finish[r] += 1;
            }

        }

        int cur = 0;
        for (int i = 0; i < n; i++) {
            cur += start[i];
            cur -= finish[i];

            long x;
            if (i == 0) {
                x = t[i];
            } else {
                x = t[i] - t[i - 1];
            }

            res[i] += x * cur;

            out.print(res[i]);
            out.print(" ");
        }

        out.close();
    }

    public static void main(String[] args) throws FileNotFoundException {
        new probB().run();
    }
}


import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class producingSnow {
	static void print(long[] r) {
		for(int i=0;i<r.length;i++)System.out.print(r[i]+" ");
		System.out.println();
	}
	public static void main (String []args) throws IOException {
		 PrintWriter pw =new PrintWriter(System.out);
	     Scanner sc=new Scanner (System.in);
	     int n=sc.nextInt();
	     long v[]=new long[n];
	     long t[]=new long[n];
	     for(int i=0;i<n;i++)v[i]=sc.nextLong();
	     for(int i=0;i<n;i++)t[i]=sc.nextLong();
	     long r[]=new long[n+1];
	     long[] f=new long [n+1];
	     long p[]=new long[n];
	     p[0]=t[0];
	     for(int i=1;i<n;i++)
	    	 p[i]=p[i-1]+t[i];

	     for(int i=0;i<n;i++) {
	    	 int s=i;
	    	 int e=n-1;int pos=n;
	    	 long pre=(i==0)?0:p[i-1];
	    	 while(s<=e) {
	    		 int mid=(s+e)/2;
	    		 if(p[mid]-pre>v[i]) {

	    			 pos=mid;
	    			 e=mid-1;
	    		 }else
	    			 s=mid+1;}
	    	if(i==0&&pos==0)r[i]=v[i];
	    	else {
	        f[i]+=1;
	    	f[pos]+=-1;
	    	r[pos]+=(i==0)?(v[i]-p[pos-1]):v[i]-(p[pos-1]-p[i-1]);
	    	}

	     }
	     for(int i=1;i<n;i++) {
	    	 f[i]=f[i]+f[i-1];
	    	 }
	     for(int i=0;i<n;i++)
	    	 pw.print((long)t[i]*f[i]+r[i]+" ");
	     pw.flush();
	     }

	 static class Scanner {

			StringTokenizer st;
			BufferedReader br;

			public Scanner(InputStream system) {
				br = new BufferedReader(new InputStreamReader(system));
			}

			public Scanner(String file) throws Exception {
				br = new BufferedReader(new FileReader(file));
			}

			public String next() throws IOException {
				while (st == null || !st.hasMoreTokens())
					st = new StringTokenizer(br.readLine());
				return st.nextToken();
			}

			public String nextLine() throws IOException {
				return br.readLine();
			}

			public int nextInt() throws IOException {
				return Integer.parseInt(next());
			}

			public double nextDouble() throws IOException {
				return Double.parseDouble(next());
			}

			public char nextChar() throws IOException {
				return next().charAt(0);
			}

			public Long nextLong() throws IOException {
				return Long.parseLong(next());
			}

			public boolean ready() throws IOException {
				return br.ready();
			}

			public void waitForInput() throws InterruptedException {
				Thread.sleep(3000);
			}}
}


import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class producingSnow {
	static void print(long[] r) {
		for(int i=0;i<r.length;i++)System.out.print(r[i]+" ");
		System.out.println();
	}
	public static void main (String []args) throws IOException {
		 PrintWriter pw =new PrintWriter(System.out);
	     Scanner sc=new Scanner (System.in);
	     int n=sc.nextInt();
	     long v[]=new long[n];
	     long t[]=new long[n];
	     for(int i=0;i<n;i++)v[i]=sc.nextLong();
	     for(int i=0;i<n;i++)t[i]=sc.nextLong();
	     long r[]=new long[n+1];
	     long[] f=new long [n+1];
	     long p[]=new long[n];
	     p[0]=t[0];
	     for(int i=1;i<n;i++)
	    	 p[i]=p[i-1]+t[i];

	     for(int i=0;i<n;i++) {
	    	 int s=i;
	    	 int e=n-1;int pos=n;
	    	 long pre=(i==0)?0:p[i-1];
	    	 while(s<=e) {
	    		 int mid=(s+e)/2;
	    		 if(p[mid]-pre>v[i]) {

	    			 pos=mid;
	    			 e=mid-1;
	    		 }else
	    			 s=mid+1;}
	    	f[i]+=1;
	    			 f[pos]+=-1;
	    	r[pos]+=(i==0)?(v[i]-p[pos-1]):v[i]-(p[pos-1]-p[i-1]);

	     }
	     for(int i=1;i<n;i++) {
	    	 f[i]=f[i]+f[i-1];
	    	 }
	     for(int i=0;i<n;i++)
	    	 pw.print(t[i]*f[i]+r[i]+" ");
	     pw.flush();
	     }

	 static class Scanner {

			StringTokenizer st;
			BufferedReader br;

			public Scanner(InputStream system) {
				br = new BufferedReader(new InputStreamReader(system));
			}

			public Scanner(String file) throws Exception {
				br = new BufferedReader(new FileReader(file));
			}

			public String next() throws IOException {
				while (st == null || !st.hasMoreTokens())
					st = new StringTokenizer(br.readLine());
				return st.nextToken();
			}

			public String nextLine() throws IOException {
				return br.readLine();
			}

			public int nextInt() throws IOException {
				return Integer.parseInt(next());
			}

			public double nextDouble() throws IOException {
				return Double.parseDouble(next());
			}

			public char nextChar() throws IOException {
				return next().charAt(0);
			}

			public Long nextLong() throws IOException {
				return Long.parseLong(next());
			}

			public boolean ready() throws IOException {
				return br.ready();
			}

			public void waitForInput() throws InterruptedException {
				Thread.sleep(3000);
			}}
}


import java.io.*;
import java.util.*;

public	 class CODEFORCES
	{
		private InputStream is;
		private PrintWriter out;
		int time = 0, DP[], start[], end[], dist[], black[], MOD = (int) (1e9 + 7),
				arr[], weight[][], x[], y[], parent[];
		int MAX = 100000, N, K;
		long red[];
		ArrayList<Integer>[] amp;
		ArrayList<Pair>[][] pmp;
		boolean b[], boo[][];
		Pair prr[];
		HashMap<Pair, Integer> hm = new HashMap();
		long Dp[][][][] = new long[110][110][12][12];

		void soln()
		{
			is = System.in;
			out = new PrintWriter(System.out);
			long s = System.currentTimeMillis();
			solve();
			// out.close();
			out.flush();
			// tr(System.currentTimeMillis() - s + "ms");
		}

		public static void main(String[] args) throws Exception
		{
			new Thread(null, new Runnable()
			{
				public void run()
				{
					try
					{
						// new CODEFORCES().soln();
					} catch (Exception e)
					{
						System.out.println(e);
					}
				}
			}, "1", 1 << 26).start();
			new CODEFORCES().soln();
		}

		int ans = 0, cost = 0, D[][];
		char ch[], ch1[];
		int hash = 29;
		TreeSet<Cell> ts;
		int prime[] = new int[100000];
		int dp[] = new int[50000];
		TreeSet<String> tset = new TreeSet<>();
		void solve()
		{
			int n = ni();
			int arr[] = na(n);
			int brr[] = na(n);
			long ans[] = new long[2*n+1];
			long val[] = new long[n+1];
			int temp[] = new int[2*n+1];
			for(int i = 1; i<=n; i++) {
				val[i] = val[i-1]+brr[i-1];
			}
			printArray(val);
			for(int i = 0; i< n; i++) {
				int x = Arrays.binarySearch(val, arr[i]+val[i]);
				if(x<0) {
					x = -x-2;
				}
				System.out.println(x);
				temp[i+1]++;
				temp[x+1]--;
				ans[x+1] += arr[i] + val[i] - val[x];
				printArray(ans);
			}
			for(int i = 1;i<=n;i++) {
				temp[i] += temp[i-1];
			}
			for(int i = 1; i<=n;i++) {
				ans[i] += temp[i]*1l*brr[i-1];
				out.print(ans[i]+" ");
			}
		}
		void printArray(long[] arr) {
			for(long i : arr) out.print(i +" ");
			out.println();
		}
		void bfs(int x) {
			Queue<Integer> q = new LinkedList<>();
			q.add(x);
			arr[x] = 0;
			while(!q.isEmpty()) {
				int y = q.poll();
				for(int i : amp[y]) {
					arr[i] = min(arr[i],arr[y]+1);
					if(!b[i]) {
						q.add(i);
						b[i] = true;
					}
				}
			}
		}
		long calc(char ch[]) {
			long val = 1, sum = 0;
			for(char c : ch) {
				if(c == 'S') sum += val;
				else val*=2;
			}
			return sum;
		}
		int dfs(int x) {
			b[x] = true;
			start[x] = time++;
			int ans = 1;
			for(int i : amp[x]) {
				if(!b[i]) {
					ans += dfs(i);
				}
			}
			end[x] = time;
			return dist[x] = ans;
		}
		int calc(int x) {
			String s = Integer.toString(x);
			int ans = 0;
			for(char ch : s.toCharArray()) ans += (ch-'0');
			return ans;
		}
		boolean isCons(char ch){
			if(ch!='a' && ch!='e' && ch!='i' && ch!='o' && ch!='u' && ch!=' ') return true;
			return false;
		}
		void seive(int x){
			b = new boolean[x+1];
			for(int i = 2;i*i<=x;i++){
				if(!b[i]){
					for(int j = 2*i;j<=x;j+=i) b[j] = true;
				}
			}
		}
		long[][] matMul(long a[][] , long b[][], int n)
		{
			long res[][] = new long[n][n];
			for(int i = 0;i<n;i++){
				for(int j = 0;j<n;j++){
					long sum = 0;
					for(int k = 0;k<n;k++){
						sum += (a[i][k]*1l*b[k][j]);
						sum %= MOD;
					}
					res[i][j] = sum;
				}
			}
			return res;
		}
		int min(int a, int b)
		{
			return (a<b)?a:b;
		}
		private class Cell implements Comparable<Cell>
		{
			int u, v, s;
			public Cell(int u, int v, int s)
			{
				this.u = u;
				this.v = v;
				this.s = s;
			}
			public int hashCode()
			{
				return Objects.hash();
			}
			public int compareTo(Cell other)
			{
				return (Long.compare(s, other.s) != 0 ? (Long.compare(s, other.s)):(Long.compare(v, other.v)!=0?Long.compare(v, other.v):Long.compare(u, other.u)))
						&((Long.compare(s, other.s) != 0 ? (Long.compare(s, other.s)):(Long.compare(u, other.v)!=0?Long.compare(u, other.v):Long.compare(v, other.u))));
			}
			public String toString()
			{
				return this.u + " " + this.v;
			}
		}

		class Pair implements Comparable<Pair>
		{
			int u, v, z, i;

			Pair(int u, int v)
			{
				this.u = u;
				this.v = v;
			}

			Pair()
			{

			}

			Pair(int u, int v, int z, int i)
			{
				this.u = u;
				this.v = v;
				this.z = z;
				this.i = i;
			}

			public int hashCode()
			{
				return Objects.hash();
			}

			public boolean equals(Object o)
			{
				Pair other = (Pair) o;
				return (((u == other.v && v == other.u)));
			}

			public int compareTo(Pair other)
			{
				//return (((u == other.v && v == other.u)))?0:1;
				// return Integer.compare(val, other.val);
				return Long.compare(v, other.v);// != 0 ? (Long.compare(u, other.u)): (Long.compare(v, other.v));
						//&(Long.compare(u, other.v) != 0 ? (Long.compare(u, other.v)): (Long.compare(v, other.u))));
			}

			public String toString()
			{
				return this.u + " " + this.v;
			}
		}

		int max(int a, int b)
		{
			if (a > b)
				return a;
			return b;
		}

		void buildGraph(int n)
		{
			for (int i = 0; i < n; i++)
			{
				int x1 = ni() - 1, y1 = ni() - 1;
				amp[x1].add(y1);
				amp[y1].add(x1);
			}
		}
		long modInverse(long a, long mOD2)
		{
			return power(a, mOD2 - 2, mOD2);
		}

		long power(long x, long y, long m)
		{
			if (y == 0)
				return 1;
			long p = power(x, y / 2, m) % m;
			p = (p * p) % m;

			return (y % 2 == 0) ? p : (x * p) % m;
		}

		public long gcd(long a, long b)
		{
			if (b == 0)
				return a;
			return gcd(b, a % b);
		}

		static class ST1
		{
			int arr[], st[], size;

			ST1(int a[])
			{
				arr = a.clone();
				size = 10 * arr.length;
				st = new int[size];
				build(0, arr.length - 1, 1);
			}

			void build(int ss, int se, int si)
			{
				if (ss == se)
				{
					st[si] = arr[ss];
					return;
				}
				int mid = (ss + se) / 2;
				int val = 2 * si;
				build(ss, mid, val);
				build(mid + 1, se, val + 1);
				st[si] = Math.min(st[val], st[val + 1]);
			}

			int get(int ss, int se, int l, int r, int si)
			{
				if (l > se || r < ss || l > r)
					return Integer.MAX_VALUE;
				if (l <= ss && r >= se)
					return st[si];
				int mid = (ss + se) / 2;
				int val = 2 * si;
				return Math.min(get(ss, mid, l, r, val),
						get(mid + 1, se, l, r, val + 1));
			}
		}

		static class ST
		{
			int arr[], lazy[], n;

			ST(int a)
			{
				n = a;
				arr = new int[10 * n];
				lazy = new int[10 * n];
			}

			void up(int l, int r, int val)
			{
				update(0, n - 1, 0, l, r, val);
			}

			void update(int l, int r, int c, int x, int y, int val)
			{
				if (lazy[c] != 0) {
					lazy[2 * c + 1] += lazy[c];
					lazy[2 * c + 2] += lazy[c];
					if (l == r)
						arr[c] += lazy[c];
					lazy[c] = 0;
				}
				if (l > r || x > y || l > y || x > r)
					return;
				if (x <= l && y >= r)

				{
					lazy[c] += val;
					return;
				}
				int mid = l + r >> 1;
				update(l, mid, 2 * c + 1, x, y, val);
				update(mid + 1, r, 2 * c + 2, x, y, val);
				arr[c] = Math.max(arr[2 * c + 1], arr[2 * c + 2]);
			}

			int an(int ind)
			{
				return ans(0, n - 1, 0, ind);
			}

			int ans(int l, int r, int c, int ind)
			{
				if (lazy[c] != 0)
				{
					lazy[2 * c + 1] += lazy[c];
					lazy[2 * c + 2] += lazy[c];
					if (l == r)
						arr[c] += lazy[c];
					lazy[c] = 0;
				}
				if (l == r)
					return arr[c];
				int mid = l + r >> 1;
				if (mid >= ind)
					return ans(l, mid, 2 * c + 1, ind);
				return ans(mid + 1, r, 2 * c + 2, ind);
			}
		}

		public static int[] shuffle(int[] a, Random gen)
		{
			for (int i = 0, n = a.length; i < n; i++)
			{
				int ind = gen.nextInt(n - i) + i;
				int d = a[i];
				a[i] = a[ind];
				a[ind] = d;
			}
			return a;
		}

		long power(long x, long y, int mod)
		{
			long ans = 1;
			while (y > 0)
			{
				if (y % 2 == 0)
				{
					x = (x * x) % mod;
					y /= 2;
				} else
				{
					ans = (x * ans) % mod;
					y--;
				}
			}
			return ans;
		}

		// To Get Input
		// Some Buffer Methods
		private byte[] inbuf = new byte[1024];
		public int lenbuf = 0, ptrbuf = 0;

		private int readByte()
		{
			if (lenbuf == -1)
				throw new InputMismatchException();
			if (ptrbuf >= lenbuf)
			{
				ptrbuf = 0;
				try
				{
					lenbuf = is.read(inbuf);
				} catch (IOException e)
				{
					throw new InputMismatchException();
				}
				if (lenbuf <= 0)
					return -1;
			}
			return inbuf[ptrbuf++];
		}

		private boolean isSpaceChar(int c)
		{
			return !(c >= 33 && c <= 126);
		}

		private int skip()
		{
			int b;
			while ((b = readByte()) != -1 && isSpaceChar(b))
				;
			return b;
		}

		private double nd()
		{
			return Double.parseDouble(ns());
		}

		private char nc()
		{
			return (char) skip();
		}

		private String ns()
		{
			int b = skip();
			StringBuilder sb = new StringBuilder();
			while (!(isSpaceChar(b)))
			{ // when nextLine, (isSpaceChar(b) && b != '
										// ')
				sb.appendCodePoint(b);
				b = readByte();
			}
			return sb.toString();
		}

		private char[] ns(int n)
		{
			char[] buf = new char[n];
			int b = skip(), p = 0;
			while (p < n && !(isSpaceChar(b)))
			{
				buf[p++] = (char) b;
				b = readByte();
			}
			return n == p ? buf : Arrays.copyOf(buf, p);
		}

		private char[][] nm(int n, int m)
		{
			char[][] map = new char[n][];
			for (int i = 0; i < n; i++)
				map[i] = ns(m);
			return map;
		}

		private int[] na(int n)
		{
			int[] a = new int[n];
			for (int i = 0; i < n; i++)
				a[i] = ni();
			return a;
		}

		private int ni()
		{
			int num = 0, b;
			boolean minus = false;
			while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'))
				;
			if (b == '-')
			{
				minus = true;
				b = readByte();
			}

			while (true)
			{
				if (b >= '0' && b <= '9')
				{
					num = num * 10 + (b - '0');
				} else
				{
					return minus ? -num : num;
				}
				b = readByte();
			}
		}

		private long nl()
		{
			long num = 0;
			int b;
			boolean minus = false;
			while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'))
				;
			if (b == '-')
			{
				minus = true;
				b = readByte();
			}

			while (true)
			{
				if (b >= '0' && b <= '9')
				{
					num = num * 10 + (b - '0');
				} else
				{
					return minus ? -num : num;
				}
				b = readByte();
			}
		}

		private boolean oj = System.getProperty("ONLINE_JUDGE") != null;

		private void tr(Object... o)
		{
			if (!oj)
				System.out.println(Arrays.deepToString(o));
		}
	}


import java.io.*;
import java.util.*;

public	 class CODEFORCES
	{
		private InputStream is;
		private PrintWriter out;
		int time = 0, DP[], start[], end[], dist[], black[], MOD = (int) (1e9 + 7),
				arr[], weight[][], x[], y[], parent[];
		int MAX = 100000, N, K;
		long red[];
		ArrayList<Integer>[] amp;
		ArrayList<Pair>[][] pmp;
		boolean b[], boo[][];
		Pair prr[];
		HashMap<Pair, Integer> hm = new HashMap();
		long Dp[][][][] = new long[110][110][12][12];

		void soln()
		{
			is = System.in;
			out = new PrintWriter(System.out);
			long s = System.currentTimeMillis();
			solve();
			// out.close();
			out.flush();
			// tr(System.currentTimeMillis() - s + "ms");
		}

		public static void main(String[] args) throws Exception
		{
			new Thread(null, new Runnable()
			{
				public void run()
				{
					try
					{
						// new CODEFORCES().soln();
					} catch (Exception e)
					{
						System.out.println(e);
					}
				}
			}, "1", 1 << 26).start();
			new CODEFORCES().soln();
		}

		int ans = 0, cost = 0, D[][];
		char ch[], ch1[];
		int hash = 29;
		TreeSet<Cell> ts;
		int prime[] = new int[100000];
		int dp[] = new int[50000];
		TreeSet<String> tset = new TreeSet<>();
		void solve()
		{
			int n = ni();
			int arr[] = na(n);
			int brr[] = na(n);
			long ans[] = new long[2*n+1];
			long val[] = new long[n+1];
			int temp[] = new int[2*n+1];
			for(int i = 1; i<=n; i++) {
				val[i] = val[i-1]+brr[i-1];
			}
			//printArray(val);
			for(int i = 0; i< n; i++) {
				int x = Arrays.binarySearch(val, arr[i]+val[i]);
				if(x<0) {
					x = -x-2;
				}
				//System.out.println(x);
				temp[i+1]++;
				temp[x+1]--;
				ans[x+1] += arr[i] + val[i] - val[x];
				//printArray(ans);
			}
			for(int i = 1;i<=n;i++) {
				temp[i] += temp[i-1];
			}
			for(int i = 1; i<=n;i++) {
				ans[i] += temp[i]*1l*brr[i-1];
				out.print(ans[i]+" ");
			}
		}
		void printArray(long[] arr) {
			for(long i : arr) out.print(i +" ");
			out.println();
		}
		void bfs(int x) {
			Queue<Integer> q = new LinkedList<>();
			q.add(x);
			arr[x] = 0;
			while(!q.isEmpty()) {
				int y = q.poll();
				for(int i : amp[y]) {
					arr[i] = min(arr[i],arr[y]+1);
					if(!b[i]) {
						q.add(i);
						b[i] = true;
					}
				}
			}
		}
		long calc(char ch[]) {
			long val = 1, sum = 0;
			for(char c : ch) {
				if(c == 'S') sum += val;
				else val*=2;
			}
			return sum;
		}
		int dfs(int x) {
			b[x] = true;
			start[x] = time++;
			int ans = 1;
			for(int i : amp[x]) {
				if(!b[i]) {
					ans += dfs(i);
				}
			}
			end[x] = time;
			return dist[x] = ans;
		}
		int calc(int x) {
			String s = Integer.toString(x);
			int ans = 0;
			for(char ch : s.toCharArray()) ans += (ch-'0');
			return ans;
		}
		boolean isCons(char ch){
			if(ch!='a' && ch!='e' && ch!='i' && ch!='o' && ch!='u' && ch!=' ') return true;
			return false;
		}
		void seive(int x){
			b = new boolean[x+1];
			for(int i = 2;i*i<=x;i++){
				if(!b[i]){
					for(int j = 2*i;j<=x;j+=i) b[j] = true;
				}
			}
		}
		long[][] matMul(long a[][] , long b[][], int n)
		{
			long res[][] = new long[n][n];
			for(int i = 0;i<n;i++){
				for(int j = 0;j<n;j++){
					long sum = 0;
					for(int k = 0;k<n;k++){
						sum += (a[i][k]*1l*b[k][j]);
						sum %= MOD;
					}
					res[i][j] = sum;
				}
			}
			return res;
		}
		int min(int a, int b)
		{
			return (a<b)?a:b;
		}
		private class Cell implements Comparable<Cell>
		{
			int u, v, s;
			public Cell(int u, int v, int s)
			{
				this.u = u;
				this.v = v;
				this.s = s;
			}
			public int hashCode()
			{
				return Objects.hash();
			}
			public int compareTo(Cell other)
			{
				return (Long.compare(s, other.s) != 0 ? (Long.compare(s, other.s)):(Long.compare(v, other.v)!=0?Long.compare(v, other.v):Long.compare(u, other.u)))
						&((Long.compare(s, other.s) != 0 ? (Long.compare(s, other.s)):(Long.compare(u, other.v)!=0?Long.compare(u, other.v):Long.compare(v, other.u))));
			}
			public String toString()
			{
				return this.u + " " + this.v;
			}
		}

		class Pair implements Comparable<Pair>
		{
			int u, v, z, i;

			Pair(int u, int v)
			{
				this.u = u;
				this.v = v;
			}

			Pair()
			{

			}

			Pair(int u, int v, int z, int i)
			{
				this.u = u;
				this.v = v;
				this.z = z;
				this.i = i;
			}

			public int hashCode()
			{
				return Objects.hash();
			}

			public boolean equals(Object o)
			{
				Pair other = (Pair) o;
				return (((u == other.v && v == other.u)));
			}

			public int compareTo(Pair other)
			{
				//return (((u == other.v && v == other.u)))?0:1;
				// return Integer.compare(val, other.val);
				return Long.compare(v, other.v);// != 0 ? (Long.compare(u, other.u)): (Long.compare(v, other.v));
						//&(Long.compare(u, other.v) != 0 ? (Long.compare(u, other.v)): (Long.compare(v, other.u))));
			}

			public String toString()
			{
				return this.u + " " + this.v;
			}
		}

		int max(int a, int b)
		{
			if (a > b)
				return a;
			return b;
		}

		void buildGraph(int n)
		{
			for (int i = 0; i < n; i++)
			{
				int x1 = ni() - 1, y1 = ni() - 1;
				amp[x1].add(y1);
				amp[y1].add(x1);
			}
		}
		long modInverse(long a, long mOD2)
		{
			return power(a, mOD2 - 2, mOD2);
		}

		long power(long x, long y, long m)
		{
			if (y == 0)
				return 1;
			long p = power(x, y / 2, m) % m;
			p = (p * p) % m;

			return (y % 2 == 0) ? p : (x * p) % m;
		}

		public long gcd(long a, long b)
		{
			if (b == 0)
				return a;
			return gcd(b, a % b);
		}

		static class ST1
		{
			int arr[], st[], size;

			ST1(int a[])
			{
				arr = a.clone();
				size = 10 * arr.length;
				st = new int[size];
				build(0, arr.length - 1, 1);
			}

			void build(int ss, int se, int si)
			{
				if (ss == se)
				{
					st[si] = arr[ss];
					return;
				}
				int mid = (ss + se) / 2;
				int val = 2 * si;
				build(ss, mid, val);
				build(mid + 1, se, val + 1);
				st[si] = Math.min(st[val], st[val + 1]);
			}

			int get(int ss, int se, int l, int r, int si)
			{
				if (l > se || r < ss || l > r)
					return Integer.MAX_VALUE;
				if (l <= ss && r >= se)
					return st[si];
				int mid = (ss + se) / 2;
				int val = 2 * si;
				return Math.min(get(ss, mid, l, r, val),
						get(mid + 1, se, l, r, val + 1));
			}
		}

		static class ST
		{
			int arr[], lazy[], n;

			ST(int a)
			{
				n = a;
				arr = new int[10 * n];
				lazy = new int[10 * n];
			}

			void up(int l, int r, int val)
			{
				update(0, n - 1, 0, l, r, val);
			}

			void update(int l, int r, int c, int x, int y, int val)
			{
				if (lazy[c] != 0) {
					lazy[2 * c + 1] += lazy[c];
					lazy[2 * c + 2] += lazy[c];
					if (l == r)
						arr[c] += lazy[c];
					lazy[c] = 0;
				}
				if (l > r || x > y || l > y || x > r)
					return;
				if (x <= l && y >= r)

				{
					lazy[c] += val;
					return;
				}
				int mid = l + r >> 1;
				update(l, mid, 2 * c + 1, x, y, val);
				update(mid + 1, r, 2 * c + 2, x, y, val);
				arr[c] = Math.max(arr[2 * c + 1], arr[2 * c + 2]);
			}

			int an(int ind)
			{
				return ans(0, n - 1, 0, ind);
			}

			int ans(int l, int r, int c, int ind)
			{
				if (lazy[c] != 0)
				{
					lazy[2 * c + 1] += lazy[c];
					lazy[2 * c + 2] += lazy[c];
					if (l == r)
						arr[c] += lazy[c];
					lazy[c] = 0;
				}
				if (l == r)
					return arr[c];
				int mid = l + r >> 1;
				if (mid >= ind)
					return ans(l, mid, 2 * c + 1, ind);
				return ans(mid + 1, r, 2 * c + 2, ind);
			}
		}

		public static int[] shuffle(int[] a, Random gen)
		{
			for (int i = 0, n = a.length; i < n; i++)
			{
				int ind = gen.nextInt(n - i) + i;
				int d = a[i];
				a[i] = a[ind];
				a[ind] = d;
			}
			return a;
		}

		long power(long x, long y, int mod)
		{
			long ans = 1;
			while (y > 0)
			{
				if (y % 2 == 0)
				{
					x = (x * x) % mod;
					y /= 2;
				} else
				{
					ans = (x * ans) % mod;
					y--;
				}
			}
			return ans;
		}

		// To Get Input
		// Some Buffer Methods
		private byte[] inbuf = new byte[1024];
		public int lenbuf = 0, ptrbuf = 0;

		private int readByte()
		{
			if (lenbuf == -1)
				throw new InputMismatchException();
			if (ptrbuf >= lenbuf)
			{
				ptrbuf = 0;
				try
				{
					lenbuf = is.read(inbuf);
				} catch (IOException e)
				{
					throw new InputMismatchException();
				}
				if (lenbuf <= 0)
					return -1;
			}
			return inbuf[ptrbuf++];
		}

		private boolean isSpaceChar(int c)
		{
			return !(c >= 33 && c <= 126);
		}

		private int skip()
		{
			int b;
			while ((b = readByte()) != -1 && isSpaceChar(b))
				;
			return b;
		}

		private double nd()
		{
			return Double.parseDouble(ns());
		}

		private char nc()
		{
			return (char) skip();
		}

		private String ns()
		{
			int b = skip();
			StringBuilder sb = new StringBuilder();
			while (!(isSpaceChar(b)))
			{ // when nextLine, (isSpaceChar(b) && b != '
										// ')
				sb.appendCodePoint(b);
				b = readByte();
			}
			return sb.toString();
		}

		private char[] ns(int n)
		{
			char[] buf = new char[n];
			int b = skip(), p = 0;
			while (p < n && !(isSpaceChar(b)))
			{
				buf[p++] = (char) b;
				b = readByte();
			}
			return n == p ? buf : Arrays.copyOf(buf, p);
		}

		private char[][] nm(int n, int m)
		{
			char[][] map = new char[n][];
			for (int i = 0; i < n; i++)
				map[i] = ns(m);
			return map;
		}

		private int[] na(int n)
		{
			int[] a = new int[n];
			for (int i = 0; i < n; i++)
				a[i] = ni();
			return a;
		}

		private int ni()
		{
			int num = 0, b;
			boolean minus = false;
			while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'))
				;
			if (b == '-')
			{
				minus = true;
				b = readByte();
			}

			while (true)
			{
				if (b >= '0' && b <= '9')
				{
					num = num * 10 + (b - '0');
				} else
				{
					return minus ? -num : num;
				}
				b = readByte();
			}
		}

		private long nl()
		{
			long num = 0;
			int b;
			boolean minus = false;
			while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'))
				;
			if (b == '-')
			{
				minus = true;
				b = readByte();
			}

			while (true)
			{
				if (b >= '0' && b <= '9')
				{
					num = num * 10 + (b - '0');
				} else
				{
					return minus ? -num : num;
				}
				b = readByte();
			}
		}

		private boolean oj = System.getProperty("ONLINE_JUDGE") != null;

		private void tr(Object... o)
		{
			if (!oj)
				System.out.println(Arrays.deepToString(o));
		}
	}


import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author rizhiy
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskB solver = new TaskB();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskB {
        int floorSearch(int a[], int low, int high, int x) {
            if (low > high) {
                return low;
            }
            int mid = (low + high) / 2;
            if (a[mid] > x) {
                return floorSearch(a, low, mid - 1, x);
            } else if (a[mid] < x) {
                return floorSearch(a, mid + 1, high, x);
            } else {
                return mid;
            }
        }

        public void solve(int testNumber, InputReader in, PrintWriter out) {
            int n = in.nextInt();
            int[] v = new int[n];
            int[] t = new int[n];
            for (int i = 0; i < n; i++) {
                v[i] = in.nextInt();
            }
            for (int i = 0; i < n; i++) {
                t[i] = in.nextInt();
            }
            int[] d = new int[n];
            d[0] = t[0];
            for (int i = 1; i < n; i++) {
                d[i] = d[i - 1] + t[i];
            }
            int[] answ = new int[n];
            for (int i = 1; i < n; i++) {
                v[i] += d[i - 1];
            }
            for (int i = 0; i < n; i++) {
                if (v[0] > 0) {
                    answ[i] += v[0] > t[i] ? t[i] : v[0];
                    v[0] -= t[i];
                }
            }
            Integer[] a = new Integer[n];
            for (int i = 1; i < n; i++) {
                int y = floorSearch(d, i, n - 1, v[i]);
//            if (y == i){
//                answ[y] += v[i] - d[y-1];
//            }
                if (y < n) {
                    answ[y] += v[i] - d[y - 1];
                    a[i] = y - 1;
                } else
                    a[i] = y;
            }
            int[] u = new int[n + 1];
            int y = 0;
            for (int i = 0; i < n; i++) {
                if (a[i] != null) {
                    if (a[i] >= i)
                        y++;

                    u[a[i]]++;
                }
                answ[i] += y * t[i];
                y -= u[i];
                u[i] = 0;
            }
            for (int i = 0; i < n; i++) {
                out.print(answ[i] + " ");
            }
            out.println();
        }

    }

    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

    }
}


import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author rizhiy
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskB solver = new TaskB();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskB {
        int floorSearch(int a[], int low, int high, int x) {
            if (low > high) {
                return low;
            }
            int mid = (low + high) / 2;
            if (a[mid] > x) {
                return floorSearch(a, low, mid - 1, x);
            } else if (a[mid] < x) {
                return floorSearch(a, mid + 1, high, x);
            } else {
                return mid;
            }
        }

        public void solve(int testNumber, InputReader in, PrintWriter out) {
            int n = in.nextInt();
            int[] v = new int[n];
            int[] t = new int[n];
            for (int i = 0; i < n; i++) {
                v[i] = in.nextInt();
            }
            for (int i = 0; i < n; i++) {
                t[i] = in.nextInt();
            }
            int[] d = new int[n];
            d[0] = t[0];
            for (int i = 1; i < n; i++) {
                d[i] = d[i - 1] + t[i];
            }
            int[] answ = new int[n];
            for (int i = 1; i < n; i++) {
                v[i] += d[i - 1];
            }
            for (int i = 0; i < n; i++) {
                if (v[0] > 0) {
                    answ[i] += v[0] > t[i] ? t[i] : v[0];
                    v[0] -= t[i];
                }
            }
            Integer[] a = new Integer[n];
            for (int i = 1; i < n; i++) {
                int y = floorSearch(d, i, n - 1, v[i]);
                if (y == i) {
                    answ[y] += v[i] - d[y - 1];
                } else if (y < n) {
                    answ[y] += v[i] - d[y - 1];
                    a[i] = y - 1;
                } else
                    a[i] = y;
            }
            int[] u = new int[n + 1];
            int y = 0;
            for (int i = 0; i < n; i++) {
                if (a[i] != null) {
                    y++;
                    u[a[i]]++;
                }
                answ[i] += y * t[i];
                y -= u[i];
                u[i] = 0;
            }
            for (int i = 0; i < n; i++) {
                out.print(answ[i] + " ");
            }
            out.println();
        }

    }

    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

    }
}


import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author rizhiy
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskB solver = new TaskB();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskB {
        int floorSearch(long a[], int low, int high, long x) {
            if (low > high) {
                return low;
            }
            int mid = (low + high) / 2;
            if (a[mid] > x) {
                return floorSearch(a, low, mid - 1, x);
            } else if (a[mid] < x) {
                return floorSearch(a, mid + 1, high, x);
            } else {
                return mid;
            }
        }

        public void solve(int testNumber, InputReader in, PrintWriter out) {
            int n = in.nextInt();
            long[] v = new long[n];
            long[] t = new long[n];
            for (int i = 0; i < n; i++) {
                v[i] = in.nextLong();
            }
            for (int i = 0; i < n; i++) {
                t[i] = in.nextLong();
            }
            long[] d = new long[n];
            d[0] = t[0];
            for (int i = 1; i < n; i++) {
                d[i] = d[i - 1] + t[i];
            }
            long[] answ = new long[n];
            for (int i = 0; i < n; i++) {
                if (v[0] > 0) {
                    answ[i] += v[0] > t[i] ? t[i] : v[0];
                    v[0] -= t[i];
                }
            }
            Integer[] a = new Integer[n];
            for (int i = 1; i < n; i++) {
                int y = floorSearch(d, i, n - 1, v[i] + d[i] - t[i]);
                if (y < n) {
                    answ[y] += v[i] - (d[y - 1] - d[i - 1]);
                    a[i] = y - 1;
                } else
                    a[i] = y;
            }
            long[] u = new long[n + 1];
            long y = 0;
            for (int i = 0; i < n; i++) {
                if (a[i] != null) {
                    if (a[i] >= i) {
                        y++;
                        u[a[i]]++;
                    }
                }
                answ[i] += y * t[i];
                y -= u[i];
                u[i] = 0;
            }
            for (int i = 0; i < n; i++) {
                out.print(answ[i] + " ");
            }
            out.println();
        }

    }

    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

        public long nextLong() {
            return Long.parseLong(next());
        }

    }
}


import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author rizhiy
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskB solver = new TaskB();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskB {
        int floorSearch(int a[], int low, int high, int x) {
            if (low > high) {
                return low;
            }
            int mid = (low + high) / 2;
            if (a[mid] > x) {
                return floorSearch(a, low, mid - 1, x);
            } else if (a[mid] < x) {
                return floorSearch(a, mid + 1, high, x);
            } else {
                return mid;
            }
        }

        public void solve(int testNumber, InputReader in, PrintWriter out) {
            int n = in.nextInt();
            int[] v = new int[n];
            int[] t = new int[n];
            for (int i = 0; i < n; i++) {
                v[i] = in.nextInt();
            }
            for (int i = 0; i < n; i++) {
                t[i] = in.nextInt();
            }
            int[] d = new int[n];
            d[0] = t[0];
            for (int i = 1; i < n; i++) {
                d[i] = d[i - 1] + t[i];
            }
            int[] answ = new int[n];
            for (int i = 0; i < n; i++) {
                if (v[0] > 0) {
                    answ[i] += v[0] > t[i] ? t[i] : v[0];
                    v[0] -= t[i];
                }
            }
            Integer[] a = new Integer[n];
            for (int i = 1; i < n; i++) {
                int y = floorSearch(d, i, n - 1, v[i] + d[i] - t[i]);
                if (y < n) {
                    answ[y] += v[i] - (d[y - 1] - d[i - 1]);
                    a[i] = y - 1;
                } else
                    a[i] = y;
            }
            int[] u = new int[n + 1];
            int y = 0;
            for (int i = 0; i < n; i++) {
                if (a[i] != null) {
                    if (a[i] >= i) {
                        y++;
                        u[a[i]]++;
                    }
                }
                answ[i] += y * t[i];
                y -= u[i];
                u[i] = 0;
            }
            for (int i = 0; i < n; i++) {
                out.print(answ[i] + " ");
            }
            out.println();
        }

    }

    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

    }
}


import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author rizhiy
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskB solver = new TaskB();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskB {
        int floorSearch(int a[], int low, int high, int x) {
            if (low > high) {
                return low;
            }
            int mid = (low + high) / 2;
            if (a[mid] > x) {
                return floorSearch(a, low, mid - 1, x);
            } else if (a[mid] < x) {
                return floorSearch(a, mid + 1, high, x);
            } else {
                return mid;
            }
        }

        public void solve(int testNumber, InputReader in, PrintWriter out) {
            int n = in.nextInt();
            int[] v = new int[n];
            int[] t = new int[n];
            for (int i = 0; i < n; i++) {
                v[i] = in.nextInt();
            }
            for (int i = 0; i < n; i++) {
                t[i] = in.nextInt();
            }
            int[] d = new int[n];
            d[0] = t[0];
            for (int i = 1; i < n; i++) {
                d[i] = d[i - 1] + t[i];
            }
            int[] answ = new int[n];
            for (int i = 1; i < n; i++) {
                if (t[i] >= v[i]) {
                    answ[i] += v[i];
                    v[i] = 0;
                }
            }
            for (int i = 1; i < n; i++) {
                v[i] += d[i - 1];
            }
            for (int i = 0; i < n; i++) {
                if (v[0] > 0) {
                    answ[i] += v[0] > t[i] ? t[i] : v[0];
                    v[0] -= t[i];
                }
            }
//        for (int j = 0 ; j < n; j++){
//            out.print(answ[j] + " ");
//        }
//        out.println();
            Integer[] a = new Integer[n];
            for (int i = 1; i < n; i++) {
//            out.println(i);
//            for (int j = 0 ; j < n; j++){
//                out.print(v[j] + " ");
//            }
//            out.println();
//            for (int j = 0 ; j < n; j++){
//                out.print(d[j] + " ");
//            }
//            out.println();
                int y = floorSearch(d, i, n - 1, v[i]);
//            System.out.println(y);
                if (y == i) {
                    answ[y] += v[i] - d[y - 1];
                } else if (y < n) {
                    answ[y] += v[i] - d[y - 1];
                    a[i] = y - 1;
                } else
                    a[i] = y;
//            for (int j = 0 ; j < n; j++){
//                out.print(answ[j] + " ");
//            }
//            out.println();
            }
            int[] u = new int[n + 1];
            int y = 0;
            for (int i = 0; i < n; i++) {
                if (a[i] != null) {
                    y++;
                    u[a[i]]++;
//                out.println(i + " " + a[i] + " " + y);
                }
                answ[i] += y * t[i];
                y -= u[i];
                u[i] = 0;
            }
            for (int i = 0; i < n; i++) {
                out.print(answ[i] + " ");
            }
            out.println();
        }

    }

    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

    }
}