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.
    /* 
     * UMANG PANCHAL
     * DAIICT
     */
     
    import java.util.*;
    import java.io.*;
    import java.math.BigInteger;
    import java.util.Comparator;
    public class Main
    {
     
    	private static final Comparator<? super Integer> Comparator = null;
    	static LinkedList<Integer> adj[];
    	static ArrayList<Integer> adj1[];
    	static int[] color,visited1;
    	static boolean b[],visited[],possible;
    	static int level[];
    	static Map<Integer,HashSet<Integer>> s;
    	static int totalnodes,colored;
    	static int count[];
    	static long sum[];
    	static int nodes;
    	static long ans=0;
    	static long[] as=new long[10001];
    	static long c1=0,c2=0;
    	static int[] a,d,k;
    	static int max=100000000;
    	static long MOD = (long) (1e9+7),sm=0,m=Long.MIN_VALUE;
    	static boolean[] prime=new boolean[1000005];
    	static int[] levl;
        static int[] eat;
        static int price[];
        static int res[],par[];
        static int result=0;
        static int[] root,size;
        static int[][] K,p;
        static boolean yes = true;
        static long P=Long.MAX_VALUE;
        static int start,end;
    	// --------------------My Code Starts Here----------------------
    	
    	public static void main(String[] args) throws IOException
    	{
    		in=new InputReader(System.in);
    		w=new PrintWriter(System.out);
    		int n=ni();
    		long[] a=new long[n+1];
    		long[] b=new long[n+1];
    		long[] ans=new long[n+2];
    		long[] pre=new long[n+1];
    		long[] co=new long[n+2];
    		for(int i=1;i<=n;i++)
    			a[i]=nl();
    		for(int i=1;i<=n;i++)
    		{
    			b[i]=nl();
    			pre[i]=b[i]+pre[i-1];
    		}
    		for(int i=1;i<=n;i++)
    		{
    			if(b[i]>=a[i])
    			ans[i]+=a[i];
    			else
    			{
    				long sum=pre[i-1]+a[i];
    				int l=i,r=n,as=r;
    				while(r>=l)
    				{
    					int mid=(l+r)/2;
    					if(pre[mid]==sum)
    					{
    						as=mid;
    						break;
    					}
    					else if(pre[mid]>sum)
    					{
    						r=mid-1;
    						as=r;
    					}
    					else
    						l=mid+1;
    				}
    				//w.print(arg0);
    				co[i]++;
    				co[as+1]-=1;
    				ans[as+1]+=sum-pre[as];
    			}
    		}
    		for(int i=1;i<=n;i++)
    			co[i]+=co[i-1];
    		for(int i=1;i<=n;i++)
    		{
    			long ns=co[i]*b[i]+ans[i];
    			w.print(ns+" ");
    		}
    		/*
    		for(int i=1;i<=n;i++)
    		{
    			w.print(co[i]+" ");
    		}
    		w.println();
    		for(int i=1;i<=n;i++)
    		{
    			w.print(ans[i]+" ");
    		}
    		*/
            w.close();
        }
     
     
    	
     
     
    	// --------------------My Code Ends Here------------------------
         
    	
    	/*
    	 *  PriorityQueue<Integer> pq = new PriorityQueue<Integer>(new Comparator<Integer>()
      			{
      				public int compare(Integer o1, Integer o2)
      				{
      					return Integer.compare(o2,o1);
      				}
      			});
    	 * 
    	 * 
    	 */
     
    	 
    	 
    	 public static void buildgraph(int n)
    	 {
             adj=new LinkedList[n];
             visited=new boolean[n];
             level=new int[n];
             par=new int[n];
             for(int i=0;i<n;i++)
             	{
            	 adj[i]=new LinkedList<Integer>();
             	
             	}
          
    	 }
    	
    	/*public static long kruskal(Pair[] p)
    	{
    		long ans=0;
    		int w=0,x=0,y=0;
    		for(int i=0;i<p.length;i++)
    		{
    			w=p[i].w;
    			x=p[i].x;
    			y=p[i].y;
    			if(root(x)!=root(y))
    			{
    				ans+=w;
    				union(x,y);
    			}
    		}
    		return ans;
    	}*/
    	
    	 static class Pair implements Comparable<Pair>
    	 {
    		int[] a;
    		long ct;
    		long c;
    	
    		Pair(int[] a,long ct,long c)
    		{
    			this.a=a;
    			this.ct=ct;
    			this.c=c;
    		}
    		public int compareTo(Pair o)
    		{
    			if(this.c==o.c)
    				return Long.compare(this.ct,o.ct);
    		  return Long.compare(this.c,o.c);
    		} 
    		
    	}
    	
    	public static int root(int i)
    	{
    		while(root[i]!=i)
    		{
    			root[i]=root[root[i]];
    			i=root[i];
    		}
    		return i;
    	}
    	
    	public static void init(int n)
    	{
    		root=new int[n+1];
    		for(int i=1;i<=n;i++)
    			root[i]=i;
    	}
    	public static void union(int a,int b)
    	{
    	    int root_a=root(a);	
    	    int root_b=root(b);
    	    root[root_a]=root_b;
    	   // size[root_b]+=size[root_a];
    	}
     
     
    	
    	public static boolean isPrime(int n)
    	{
    	    // Corner cases
    	    if (n <= 1)  return false;
    	    if (n <= 3)  return true;
    	 
    	    // This is checked so that we can skip 
    	    // middle five numbers in below loop
    	    if (n%2 == 0 || n%3 == 0)
    	    	return false;
    	 
    	    for (int i=5; i*i<=n; i=i+6)
    	        if (n%i == 0 || n%(i+2) == 0)
    	           return false;
    	 
    	    return true;
    	}
    	
     
    	
    	public static String ns()
    	{
    		return in.nextLine();
    	}
    	public static int ni()
    	{
    		return in.nextInt();
    	}
    	public static long nl()
    	{
    		return in.nextLong();
    	}
    	public static int[] na(int n)
    	{
    		a=new int[n];
    		for(int i=0;i<n;i++)
    		a[i]=ni();
    		return a;
    	}
    	public static void sieve()
    	    {
    	       int n=prime.length;
    	        for(int i=0;i<n;i++)
    	            prime[i] = true;
    	         
    	        for(int p = 2; p*p <=n; p++)
    	        {
    	            if(prime[p] == true)
    	            {
    	                for(int i = p*2; i <n; i += p)
    	                    prime[i] = false;
    	            }
    	        }
    	    }
     
      public static String rev(String s)
    	{
    		StringBuilder sb=new StringBuilder(s);
    		sb.reverse();
    		return sb.toString();
    	}
    	static long lcm(long a, long b)
    	{
    	    return a * (b / gcd(a, b));
    	}
    	static long gcd(long a, long b)
    	{
    	    while (b > 0)
    	    {
    	        long temp = b;
    	        b = a % b; // % is remainder
    	        a = temp;
    	    }
    	    return a;
    	}
    	static InputReader in;
    	static PrintWriter w;
    static class InputReader 
    {
     
    private final InputStream stream;
    private final byte[] buf = new byte[8192];
    private int curChar, snumChars;
    private SpaceCharFilter filter;
     
    public InputReader(InputStream stream)
    {
      this.stream = stream;
    }
     
    public int snext()
    {
      if (snumChars == -1)
        throw new InputMismatchException();
      if (curChar >= snumChars)
      {
        curChar = 0;
        try 
        {
          snumChars = stream.read(buf);
        }
        catch (IOException e)
        {
          throw new InputMismatchException();
        }
        if (snumChars <= 0)
          return -1;
      }
      return buf[curChar++];
    }
     
    public int nextInt() 
    {
      int c = snext();
      while (isSpaceChar(c)) 
      {
        c = snext();
      }
      int sgn = 1;
      if (c == '-')
      {
        sgn = -1;
        c = snext();
      }
      int res = 0;
      do
      {
        if (c < '0' || c > '9')
          throw new InputMismatchException();
        res *= 10;
        res += c - '0';
        c = snext();
      }
      while (!isSpaceChar(c));
      return res * sgn;
    }
     
    public long nextLong() 
    {
      int c = snext();
      while (isSpaceChar(c)) 
      {
        c = snext();
      }
      int sgn = 1;
      if (c == '-')
      {
        sgn = -1;
        c = snext();
      }
      long res = 0;
      do
      {
        if (c < '0' || c > '9')
          throw new InputMismatchException();
        res *= 10;
        res += c - '0';
        c = snext();
      }
      while (!isSpaceChar(c));
      return res * sgn;
    }	    
    public String readString() 
    {
      int c = snext();
      while (isSpaceChar(c)) 
      {
        c = snext();
      }
      StringBuilder res = new StringBuilder();
      do
      {
        res.appendCodePoint(c);
        c = snext();
      }
      while (!isSpaceChar(c));
      return res.toString();
    }
     
    public String nextLine() 
    {
      int c = snext();
      while (isSpaceChar(c))
        c = snext();
      StringBuilder res = new StringBuilder();
      do
      {
        res.appendCodePoint(c);
        c = snext();
      }
      while (!isEndOfLine(c));
      return res.toString();
    }
     
    public boolean isSpaceChar(int c)
    {
      if (filter != null)
        return filter.isSpaceChar(c);
      return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
    }
     
    private boolean isEndOfLine(int c) 
    {
      return c == '\n' || c == '\r' || c == -1;
    }
     
    public interface SpaceCharFilter
    {
      public boolean isSpaceChar(int ch);
    }
    }
    	
    }