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 *V*<sub class="lower-index">*i*</sub> 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 *T*<sub class="lower-index">*i*</sub>, each pile will reduce its volume by *T*<sub class="lower-index">*i*</sub>. 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.
The first line contains a single integer *N* (1 ≤ *N* ≤ 10<sup class="upper-index">5</sup>) — the number of days. 

The second line contains *N* integers *V*<sub class="lower-index">1</sub>, *V*<sub class="lower-index">2</sub>, ..., *V*<sub class="lower-index">*N*</sub> (0 ≤ *V*<sub class="lower-index">*i*</sub> ≤ 10<sup class="upper-index">9</sup>), where *V*<sub class="lower-index">*i*</sub> is the initial size of a snow pile made on the day *i*.

The third line contains *N* integers *T*<sub class="lower-index">1</sub>, *T*<sub class="lower-index">2</sub>, ..., *T*<sub class="lower-index">*N*</sub> (0 ≤ *T*<sub class="lower-index">*i*</sub> ≤ 10<sup class="upper-index">9</sup>), where *T*<sub class="lower-index">*i*</sub> is the temperature on the day *i*.
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.
3
10 10 5
5 7 2
5 12 4
5
30 25 20 15 10
9 10 12 4 13
9 20 35 11 25
4
0 0 0 0
1 2 3 4
0 0 0 0
10
11 39 16 34 25 3 12 11 31 16
10 0 4 9 8 9 7 8 9 2
10 0 9 27 27 30 28 17 12 4
10
20 35 4 0 6 29 4 9 17 10
0 9 4 7 5 1 4 3 9 4
0 18 12 14 10 3 12 9 26 12
1
4
5
4
1
5
4
4
1
5
5
5
2
9 3
8 2
8 3
2
9 3
4 4
4 7
2
9 3
10 2
9 2
13
1 1 1 1 1 1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1 1 1 1 1 1
import math,sys,bisect,heapq
from collections import defaultdict,Counter,deque
from itertools import groupby,accumulate
#sys.setrecursionlimit(200000000)
int1 = lambda x: int(x) - 1
input = iter(sys.stdin.buffer.read().decode().splitlines()).__next__
ilele = lambda: map(int,input().split())
alele = lambda: list(map(int, input().split()))
ilelec = lambda: map(int1,input().split())
alelec = lambda: list(map(int1, input().split()))
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
#MOD = 1000000000 + 7
def Y(c):  print(["NO","YES"][c])
def y(c):  print(["no","yes"][c])
def Yy(c):  print(["No","Yes"][c])

N = int(input())
V = alele()
T= alele()
B = [0] + list(accumulate(T))
Ans1 = [0]*(N+2)
Ans2 = [0]*(N+2)
#print(B)

for i in range(N):
    x = V[i]
    if T[i] < V[i]:
        a = bisect.bisect_left(B,x + B[i])
        #print(x+B[i],a)
        Ans2[i] += 1
        #print(i,a)
        Ans2[a-1] -= 1
        if T[i] < V[i]:
            z = B[a-1] - B[i]
            zz = V[i] -z
            Ans1[a-1] +=zz
            #print(zz)
        #print(Ans2)
        #print(Ans1)
    else:
        Ans1[i] += V[i]
C = list(accumulate(Ans2))
#print(C)
#print(Ans1)
for i in range(N):
    print((C[i]*T[i]) + Ans1[i],end = ' ')