Recently, Polycarp completed $n$ successive tasks.

For each completed task, the time $s_i$ is known when it was given, no two tasks were given at the same time. Also given is the time $f_i$ when the task was completed. For each task, there is an unknown value $d_i$ ($d_i>0$) — duration of task execution.

It is known that the tasks were completed in the order in which they came. Polycarp performed the tasks as follows:

As soon as the very first task came, Polycarp immediately began to carry it out.

If a new task arrived before Polycarp finished the previous one, he put the new task at the end of the queue.

When Polycarp finished executing the next task and the queue was not empty, he immediately took a new task from the head of the queue (if the queue is empty — he just waited for the next task).

Find $d_i$ (duration) of each task.


-----Input-----

The first line contains a single integer $t$ ($1 \le t \le 10^4$) — the number of test cases.

The descriptions of the input data sets follow.

The first line of each test case contains one integer $n$ ($1 \le n \le 2 \cdot 10^5$).

The second line of each test case contains exactly $n$ integers $s_1 < s_2 < \dots < s_n$ ($0 \le s_i \le 10^9$).

The third line of each test case contains exactly $n$ integers $f_1 < f_2 < \dots < f_n$ ($s_i < f_i \le 10^9$).

It is guaranteed that the sum of $n$ over all test cases does not exceed $2 \cdot 10^5$.


-----Output-----

For each of $t$ test cases print $n$ positive integers $d_1, d_2, \dots, d_n$ — the duration of each task.


-----Examples-----

Input
4
3
0 3 7
2 10 11
2
10 15
11 16
9
12 16 90 195 1456 1569 3001 5237 19275
13 199 200 260 9100 10000 10914 91066 5735533
1
0
1000000000
Output
2 7 1 
1 1 
1 183 1 60 7644 900 914 80152 5644467 
1000000000


-----Note-----

First test case:

The queue is empty at the beginning: $[ ]$. And that's where the first task comes in. At time $2$, Polycarp finishes doing the first task, so the duration of the first task is $2$. The queue is empty so Polycarp is just waiting.

At time $3$, the second task arrives. And at time $7$, the third task arrives, and now the queue looks like this: $[7]$.

At the time $10$, Polycarp finishes doing the second task, as a result, the duration of the second task is $7$.

And at time $10$, Polycarp immediately starts doing the third task and finishes at time $11$. As a result, the duration of the third task is $1$.

An example of the first test case.

Difficulty: EASY

Solutions:
import os
import sys
import string
import math
n = int(input())

def solve(startTimes, endTimes, numTasks):
	workTimes = []
	counter = 0
	outStr = ''
	for s in range(numTasks):
		if startTimes[s] > counter:
			counter = startTimes[s]
		wTime = endTimes[s] - counter
		workTimes.append(wTime)
		counter = endTimes[s]
		outStr += f'{wTime} '
	print(outStr)
for i in range(n):
	numTasks = int(input())
	startTimes = input().split(' ')
	endTimes = input().split(' ')
	startTimes = list(map(lambda x: int(x), startTimes))
	endTimes = list(map(lambda x: int(x), endTimes))
	solve(startTimes, endTimes, numTasks)


for _ in range(int(input())):
	n = int(input())
	s = list(map(int, input().split()))
	f = list(map(int, input().split()))
	ans = f'{f[0] - s[0]} '
	for i in range(1, n):
		ans += f'{f[i] - max(f[i - 1], s[i])} '
	print(ans)


from posixpath import split
t = int(input())
for _ in range(t):
	n = int(input())
	a = list(map(int, input().split()))
	b = list(map(int, input().split()))
	f = 0
	ans = ''
	for i in range(n):
		ans += str(b[i] - max(a[i], f)) + ' '
		f = b[i]
	print(ans)


for _ in range(int(input())):
	n = input()
	a = list(map(int, input().split()))
	b = list(map(int, input().split()))
	out = ''
	out += str(b[0] - a[0]) + ' '
	for i in range(1, len(b)):
		out += str(b[i] - max(b[i - 1], a[i])) + ' '
	print(out)


for _ in range(int(input())):
	a = int(input())
	s1 = list(map(int, input().split()))
	s2 = list(map(int, input().split()))
	count = 0
	for z in range(1, a):
		if s1[z] < s2[z - 1]:
			s1[z] = s2[z - 1]
	ans = ''
	for p in range(a):
		ans += str(s2[p] - s1[p]) + ' '
	print(ans)


tc = int(input())
while tc > 0:
	flag = 0
	n = int(input())
	A = [int(i) for i in input().split(' ')]
	B = [int(i) for i in input().split(' ')]
	x = '{} '.format(B[0] - A[0])
	for i in range(1, n):
		if A[i] > B[i - 1]:
			x = x + '{} '.format(B[i] - A[i])
		else:
			x = x + '{} '.format(B[i] - B[i - 1])
	print(x)
	tc = tc - 1


n = int(input())
for i in range(n):
	x = input()
	s = list(map(int, input().split(' ')))
	f = list(map(int, input().split(' ')))
	out = str()
	for j in range(len(f)):
		if j == 0:
			out += str(f[0] - s[0])
		elif s[j] < f[j - 1]:
			out += str(f[j] - f[j - 1])
		else:
			out += str(f[j] - s[j])
		out += ' '
	print(out)


for t in range(int(input())):
	n = int(input())
	arr1 = list(map(int, input().split()))
	arr2 = list(map(int, input().split()))
	s = ''
	for i in range(n):
		if i != 0 and arr1[i] >= arr2[i - 1] or i == 0:
			s += str(arr2[i] - arr1[i]) + ' '
		else:
			s += str(arr2[i] - arr2[i - 1]) + ' '
	print(s)


t = int(input())
for p in range(t):
	n = int(input())
	si = list(map(int, input().split()))
	fi = list(map(int, input().split()))
	pl = [fi[0] - si[0]]
	for i in range(1, n):
		if si[i] >= fi[i - 1]:
			pl.append(fi[i] - si[i])
		else:
			pl.append(fi[i] - fi[i - 1])
	ch = ''
	for i in range(n):
		ch += str(pl[i]) + ' '
	print(ch)


from collections import defaultdict
import math as m
import sys
input = sys.stdin.readline

def get2int():
	p = input().split()
	return (int(p[0]), int(p[1]))

def get3int():
	p = input().split()
	return (int(p[0]), int(p[1]), int(p[2]))

def get4int():
	p = input().split()
	return (int(p[0]), int(p[1]), int(p[2]), int(p[3]))

def cinarr():
	return [int(i) for i in input().split()]

def solve():
	n = int(input())
	a = cinarr()
	b = cinarr()
	done = [0] * n
	done[0] = b[0] - a[0]
	for i in range(1, n):
		if a[i] >= b[i - 1]:
			done[i] = b[i] - a[i]
		else:
			done[i] = b[i] - b[i - 1]
	for i in range(n):
		print(done[i], end=' ')
	print()
for case in range(int(input())):
	solve()