Alice likes snow a lot! Unfortunately, this year's winter is already over, and she can't expect to have any more of it. Bob has thus bought her a gift — a large snow maker. He plans to make some amount of snow every day. On day i he will make a pile of snow of volume Vi and put it in her garden.

Each day, every pile will shrink a little due to melting. More precisely, when the temperature on a given day is Ti, each pile will reduce its volume by Ti. If this would reduce the volume of a pile to or below zero, it disappears forever. All snow piles are independent of each other. 

Note that the pile made on day i already loses part of its volume on the same day. In an extreme case, this may mean that there are no piles left at the end of a particular day.

You are given the initial pile sizes and the temperature on each day. Determine the total volume of snow melted on each day. 

Input

The first line contains a single integer N (1 ≤ N ≤ 105) — the number of days. 

The second line contains N integers V1, V2, ..., VN (0 ≤ Vi ≤ 109), where Vi is the initial size of a snow pile made on the day i.

The third line contains N integers T1, T2, ..., TN (0 ≤ Ti ≤ 109), where Ti is the temperature on the day i.

Output

Output a single line with N integers, where the i-th integer represents the total volume of snow melted on day i.

Examples

Input

3
10 10 5
5 7 2


Output

5 12 4


Input

5
30 25 20 15 10
9 10 12 4 13


Output

9 20 35 11 25

Note

In the first sample, Bob first makes a snow pile of volume 10, which melts to the size of 5 on the same day. On the second day, he makes another pile of size 10. Since it is a bit warmer than the day before, the first pile disappears completely while the second pile shrinks to 3. At the end of the second day, he has only a single pile of size 3. On the third day he makes a smaller pile than usual, but as the temperature dropped too, both piles survive till the end of the day.
import java.awt.List;
			    		import java.io.*;
			import java.math.BigInteger;
			import java.util.*;

			    		
			    		
			    		/*
			    		 * 
			    		 * daiict
			    		 *
			    		 * 
			    		 * 
			    		 */
			    		
			    		
			    		public class pprac {
			    			 FastScanner in;
			    			 PrintWriter out;
			    		
			    			static ArrayList[] adj;
			    			static ArrayList[] aadj;
			    		    static int last;
			    			static int n;
			    			static int m;
			    			
			    			static int[] dp1;
			    			static int[] dp2;
			    			static int color[];
			    			static int visited[];
			    			static long[] arr;
			    			static long[] brr;
			    			static double ans;
			    			static int array[];
			    			static int start[];
			    			static int finish[];
			    			static int pref[];
			    			static int tree[];
			    			static int maxval = 32;
			    		
			    			static int ttt[];
			    			static int sum = 0;
			    			static String s;
			    		
			    			static int cc = 0;
			    			static long min = Long.MAX_VALUE;
			    			
			    			static ArrayList<Integer> segt[];
			    			
			    		//for dfs do not delete
			    			static int dir[][] ={{1,0},{0,1},{0,-1},{-1,0}};
			    			
			    		
			    			static int[] seg;
			    			static long count = 1;
			    			static long mod = (long)1e9 + 7;
			    	
			    			static int parent[];
			    			static int size[];
			    			
			    		    static int[] l;
			    		    static int[] r;
			    		    static int[] next;
			    		    static int[] cnt;
			    		    static int[] block;
			    		    
			    		    static int bblock = 1001;
			    		    
			    			static HashSet<String> set;
			    			static HashSet<String> set2;
			    			
			    			static int low[];
			    			static int disc[];
			    			static int time;
			    			static int acn[];
			    			
			    			static HashMap<Long,Integer> map;
			    			
			    			static class Pair implements Comparable<Pair>
			    		    {
			    				int x;int y;int i;
			    				
			    		        Pair(int l, int m,int i) {
			    		          
			    		        	this.x = l;
			    		            this.y = m;
			    		            this.i = i;
			    		          
			    		        }
			    		        
			    		        public int compareTo(Pair p) {
			    		      
			    		        	
			    		            if (this.x/bblock == p.x/bblock) {
			    		                return (int)(this.y-p.y);
			    		            }
			    		            return (int)(this.x/bblock - p.x/bblock);
			    		        }
			    		        
			    		        public String toString(){
			    		        	return x + " " + y;
			    		        }
			    		        
			    		        public boolean equals(Object o){
			    		        	if(o instanceof Pair){
			    		        		Pair a = (Pair)o;
			    		        		
			    		        		return this.x == a.x;
			    		        	}
			    		        	
			    		        	return false;
			    		        }
			    		        
			    		        public int hashCode(){
			    		        	return new Long(x).hashCode()*31 + new Long(y).hashCode();
			    		        }
			    		    
			    		    }
			    		    
			    			
			    			public static int gcd(int a, int b) {
			    				if (b == 0) return a;
			    				return gcd(b, a%b);
			    			}
			    	
			    			void build(int n) {  // build the tree
			  				  for (int i = n - 1; i > 0; --i) seg[i] = Math.min(seg[i<<1],seg[i<<1|1]);
			  				}
		
			  			public static void modify(int p, int val,int n) {  // set value at position p
			  				  for (seg[p += n] = val; p > 1; p >>= 1) seg[p>>1] = Math.min(seg[p],seg[p^1]);
			  				}
		
			  				int query(int l, int r,int n) {  // sum on interval [l, r)
			  				  int res = Integer.MAX_VALUE;
			  				  
			  				  if(l>r){
			  					  return res;
			  				  }
			  				  
			  				  for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
			  				    if ((l&1) == 1) res = Math.min(res, seg[l++]);
			  				    if ((r&1) == 1) res = Math.min(res, seg[--r]);
			  				  }
			  				  return res;
			  				}
			    				
	//		    			public static void update(int x,int val){
	//		    				while(x<=maxval){
	//		    					tree[x] += val;
	//		    					x = (x&-x);
	//		    				}
	//		    			}
			    			
			    			public static int read(int idx){
			    				int sum = 0;
			    				
			    				while(idx>= 0){
			    					sum += tree[idx];
			    					idx -= (idx&(-idx));
			    				}
			    				
			    				return sum;
			    			}
			    			
			    			public static int find(int i){
			    				if(parent[i] != i){
			    					return find(parent[i]);
			    				}
			    				
			    				return i;
			    			}
			    			
			    			public static void union(int a,int b){
			    				int x = find(a);
			    				int y = find(b);
			    				
			    				if(x!=y){
			    					if(size[x] > size[y]){
			    						size[x] += size[y];
			    						parent[y] = x;
			    					}else{
			    						size[y] += size[x];
			    						parent[x] = y;
			    				}
			    				}
			    			}
			    			
			    			
			    			
			    			
			    			
			    		    /*static */ void solve() throws NumberFormatException,InputMismatchException, IOException {
			    		    
			    		    	//Scanner in = new Scanner(System.in);
			    		    	
			    		    	int n = in.nextInt();
			    		    	
			    		    	long arr[] = new long[n];
			    		    	
			    		    	for(int i = 0;i<n;i++){
			    		    		arr[i] = in.nextLong();
			    		    	}
			    		    	
			    		    	long brr[] = new long[n];
			    		    	long dp[] = new long[n];
			    		    	long sum = 0;
			    		    	
			    		    	for(int i = 0;i<n;i++){
			    		    		brr[i] = in.nextLong();
			    		    		sum += brr[i];
			    		    		dp[i] = sum;
			    		    	}
			    		    	long ans[] = new long[n+1];
			    		    	long dept[] = new long[n];
			    		    	
			    		    	for(int i = 0;i<n;i++){
			    		    		long a = arr[i];
			    		    		long target = 0;
			    		    		
			    		    		if(i == 0){
			    		    			target = a;
			    		    		}else{
			    		    			target = a+dp[i-1];
			    		    		}
			    		    		
			    		    		int l = i;
			    		    		int r = n-1;
			    		    		
			    		    		while(l<r){
			    		    			int mid = (l+r)/2;
			    		    			//out.println(l +  " " + r + " " + mid);
			    		    			if(dp[mid] == target){
			    		    				l = mid;
			    		    				break;
			    		    			}else if(dp[mid] > target){
			    		    				r = mid;
			    		    			}else{
			    		    				l = mid+1;
			    		    			}
			    		    			
			    		    			
			    		    		}
			    		    		
			    		    		//out.println(dp[l]);
			    		    		ans[i] += 1;
			    		    		ans[l+1] += -1;
			    		    		long dd = (i == 0)?0:dp[i-1];
			    		    		dept[l] += Math.max(dp[l] - dd - a,0);
			    		    	
			    		    	}
			    		    	
			    		    	for(int i = 1;i<n;i++){
			    		    		ans[i] = ans[i-1] + ans[i];
			    		    	}
			    		    	
			    		    	for(int i = 0;i<n;i++){
			    		    		brr[i] = brr[i]*ans[i] - dept[i];
			    		    		out.print(brr[i] + " "/* + ans[i] + " " + dept[i] + " \n"*/);
			    		    	}
			    		    	
			    		    	
			    		    	
			    		    	
			    		    	
			    	    	}
			    			
			    	    	public static void add(int i){
			    	    		low[disc[i]]++;
			    	    		disc[i]++;
			    	    	}
			    		    
			    		    
			    		    public static void uu(int arr[],int i,int f){
			    		    	if(i == 1){
			    		    		return;
			    		    	}
			    		    	int next = i/2;
			    		    	int x = 0;
			    		    	if(i%2 == 0){
			    		    		x = i+1;
			    		    	}else{
			    		    		x = i-1;
			    		    	}
			    		    	
			    		    	if(f == 1){
			    		    		arr[next] = arr[i] ^ arr[x];
			    		    	}else{
			    		    		arr[next] = arr[i]|arr[x];
			    		    	}
			    		    	
			    		    	uu(arr,next,1-f);
			    		    }
			    		    
			    		   
				    
			    		   
			    		  
			    		
			    		    public static String reverse(String s){
			    		    	
			    		    	String ans = "";
			    		    	
			    		    	for(int i = s.length()-1;i>=0;i--){
			    		    		ans += s.charAt(i);
			    		    	}
			    		    	
			    		    	return ans;
			    		    	
			    		    }
			    			
			    			
			    		    
			    		 
			    		    public static long sum(long x){
			    		    	return x<10?x:x%10 + sum(x/10);
			    		    }
			    			
			    			public static long gcd(long x, long y) {
			    				if (x == 0)
			    					return y;
			    				else
			    					return gcd( y % x,x);
			    			}
			    			static long inv(long x , long mod)
			    			{
			    				long r,y;
			    				for(r=1,y=mod-2;y!=0;x=x*x%mod,y>>=1)
			    				{
			    					if((y&1)==1)
			    						r=r*x%mod;
			    				
			    				}
			    				return r;
			    			}
			    			
			    			public static long pow(long x,long y,long n){
			    				if(y==0)
			    					return 1%n;
			    				if(y%2==0){
			    					long z=pow(x,y/2,n);
			    					return (z*z)%n;
			    				}
			    				return ((x%n)*pow(x,y-1,n))%n;
			    			}
			    			
			    			
			    			
			    			
			    			public static boolean isPrime(long a) {
			    				// Corner cases
			    				if (a <= 1)
			    					return false;
			    				if (a <= 3)
			    					return true;
			    		 
			    				// This is checked so that we can skip 
			    				// middle five numbers in below loop
			    				if (a % 2 == 0 || a % 3 == 0)
			    					return false;
			    		 
			    				for (long i = 5; i * i <= a; i = i + 6)
			    					if (a % i == 0 || a % (i + 2) == 0)
			    						return false;
			    		 
			    				return true;
			    			}
			    			
			    		
			    			void run() throws NumberFormatException, InputMismatchException,IOException {
			    				in = new FastScanner();
			    				out = new PrintWriter(System.out);
			    		
			    				solve();
			    		
			    				out.close();
			    			}
			    		
			    			class FastScanner {
			    				BufferedReader br;
			    				StringTokenizer st;
			    		
			    				public FastScanner() {
			    					br = new BufferedReader(new InputStreamReader(System.in));
			    				}
			    		
			    				String next() {
			    					while (st == null || !st.hasMoreTokens()) {
			    						try {
			    							st = new StringTokenizer(in.br.readLine());
			    						} catch (IOException e) {
			    							// TODO Auto-generated catch block
			    							e.printStackTrace();
			    						}
			    					}
			    					return st.nextToken();
			    				}
			    		
			    				int nextInt() {
			    					return Integer.parseInt(next());
			    				}
			    		
			    				long nextLong() {
			    					return Long.parseLong(next());
			    				}
			    		
			    				double nextDouble() {
			    					return Double.parseDouble(next());
			    				}
			    			}
			    			
			    			
			    			
			    			
			    		 
			    		
			    			public static void main(String[] args) throws NumberFormatException,InputMismatchException, IOException {
	//		    				 new Thread(null ,new Runnable(){
	//		    				       public void run(){
	//		    				           try{
	//		    				        		
	//		    				               test();
	//
	//		    				           } catch(Exception e){
	//		    				               e.printStackTrace();
	//		    				           }
	//		    				       }
	//		    				   },"1",1<<26).start();
	//		    				   	   }
	//		    				    static StringBuilder sb;
	//		    				    public static void test() throws IOException{
	//		    				    	 sb=new StringBuilder();
	//		    				    	int t=1;
	//		    				    	while(t-->0){
	//		    				    		
	//		    				    		solve();
	//		    				    		
	//		    				    	}
	//		    				    	
	
		    				    new pprac().run();
			    			}
			    				    
			    			
			    		}
			    		class Node{
			    			int a;
			    			int b;
			    			public Node(int i, int j) {
								this.a = i;
								this.b = j;
								
							}
						
			    			
			    		}
			    		
			    		class MyComp implements Comparator<String>{
			    		    
			    			int c = 0;
			    			
			    			MyComp(int d){
			    				c = d;
			    			}
			    			
			    			@Override
			    			public int compare(String a,String b) {
			    				
			    				// < == -1
			    				
			    				String arr[] = a.split(" ");
			    				String brr[] = b.split(" ");
			    				
			    				return arr[c].compareTo(brr[c]);
			    				
			    				
			    			}
			
			    			
			    		}
			    		
			    		class MyComp2 implements Comparator<Node>{
			    		    
			    		
			    			
			    			@Override
			    			public int compare(Node a,Node b) {
			    				
			    				// < == -1
			
			    				
			    				if(a.b > b.b){
			    					return -1;
			    				}else{
			    					return 1;
			    				}
			    				
			    				
			    			}
			
			    			
			    		}