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
// Marcin Knapik
#include<bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")

using namespace std;

// #include <ext/pb_ds/assoc_container.hpp> // order_of_key
// #include <ext/pb_ds/tree_policy.hpp> // find by order
// using namespace __gnu_pbds; 
// #define ordered_set tree< int , null_type,less< int >, rb_tree_tag,tree_order_statistics_node_update>  

// const ll MAX_LL = 0xFFFFFFFFFFFFFFFF;
// mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
#define losuj(a, b) uniform_int_distribution<ull>(a, b)(rng)

typedef long double             ld;
typedef long long               ll;
typedef pair<int, int>          ii;
typedef vector<int>             vi;
typedef vector<ll>              vll;
typedef vector<vll>             vvll;
typedef vector<ii>              vii;
typedef vector<vi>              vvi;
typedef vector<vii>             vvii;
#define pll pair<long long, long long>

#define sz(a)                   (int)(a).size()
#define pb                      push_back
#define all(c)                  (c).begin(), (c).end()
#define rall(c)                 (c).rbegin(), (c).rend()
#define FOR(i, a)               for (int i = 0; i < (a); i++)
#define f                       first
#define s                       second

template <class T> inline bool setmin(T &a, T b){if (a > b)return a = b, 1;return 0;}
template <class T> inline bool setmax(T &a, T b){if (a < b)return a = b, 1;return 0;}

template<class T> inline T fast(T a,T b,T mod) {ll res = 1; while(b){if(b&1) res = (res*a)%mod;a = (a*a)%mod;b >>= 1;}return res;}
template<class T> istream &operator>>(istream &os, vector<T> &container){for (auto &u : container)os >> u;return os;}
template<class T> ostream &operator<<(ostream &os, const vector<T> &container){for (auto &u : container)os << u << " ";return os;}
template<class T> inline T gcd(T a, T b) { while (b)swap(a %= b, b); return a; }

const ll INF = 1e9 + 7;
const ll mod = 998244353;
const ll BIG_INF = 1e18 + 7;
const ll N = 1e6+7;
const ll T = 1<<20;
const ld inf = 1e18;

ll n, m, k, q;

multiset<ll> secik;
ll pref;

signed main(){
    ios::sync_with_stdio(0);
    cin.tie(0);

    cin >> n;
    vll kupki(n), stopnie(n);
    cin >> kupki >> stopnie;
    
    for(int i = 0; i < n; i++){
    	secik.insert(kupki[i] + pref);
    	ll wyn = 0;
    	pref += stopnie[i];
    	
    	while(sz(secik) and *secik.begin() <= pref){
    		wyn += stopnie[i] - (pref - *secik.begin());
    		secik.erase(secik.begin());
    	}
    	wyn += sz(secik) * stopnie[i];
    	cout << wyn << ' ';
    }
    cout << '\n';
}   	