You are given an array $a_1, a_2, \dots, a_n$, which is sorted in non-descending order. You decided to perform the following steps to create array $b_1, b_2, \dots, b_n$:

Create an array $d$ consisting of $n$ arbitrary non-negative integers.

Set $b_i = a_i + d_i$ for each $b_i$.

Sort the array $b$ in non-descending order.

You are given the resulting array $b$. For each index $i$, calculate what is the minimum and maximum possible value of $d_i$ you can choose in order to get the given array $b$.

Note that the minimum (maximum) $d_i$-s are independent of each other, i. e. they can be obtained from different possible arrays $d$.


-----Input-----

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

The first line of each test case contains a single integer $n$ ($1 \le n \le 2 \cdot 10^5$) — the length of arrays $a$, $b$ and $d$.

The second line contains $n$ integers $a_1, a_2, \dots, a_n$ ($1 \le a_i \le 10^9$; $a_i \le a_{i+1}$) — the array $a$ in non-descending order.

The third line contains $n$ integers $b_1, b_2, \dots, b_n$ ($1 \le b_i \le 10^9$; $b_i \le b_{i+1}$) — the array $b$ in non-descending order.

Additional constraints on the input:

there is at least one way to obtain the array $b$ from the $a$ by choosing an array $d$ consisting of non-negative integers;

the sum of $n$ doesn't exceed $2 \cdot 10^5$.


-----Output-----

For each test case, print two lines. In the first line, print $n$ integers $d_1^{min}, d_2^{min}, \dots, d_n^{min}$, where $d_i^{min}$ is the minimum possible value you can add to $a_i$.

Secondly, print $n$ integers $d_1^{max}, d_2^{max}, \dots, d_n^{max}$, where $d_i^{max}$ is the maximum possible value you can add to $a_i$.

All $d_i^{min}$ and $d_i^{max}$ values are independent of each other. In other words, for each $i$, $d_i^{min}$ is just the minimum value among all possible values of $d_i$.


-----Examples-----

Input
4
3
2 3 5
7 11 13
1
1000
5000
4
1 2 3 4
1 2 3 4
4
10 20 30 40
22 33 33 55
Output
5 4 2
11 10 8
4000
4000
0 0 0 0
0 0 0 0
12 2 3 15
23 13 3 15


-----Note-----

In the first test case, in order to get $d_1^{min} = 5$, we can choose, for example, $d = [5, 10, 6]$. Then $b$ $=$ $[2+5,3+10,5+6]$ $=$ $[7,13,11]$ $=$ $[7,11,13]$.

For $d_2^{min} = 4$, we can choose $d$ $=$ $[9, 4, 8]$. Then $b$ $=$ $[2+9,3+4,5+8]$ $=$ $[11,7,13]$ $=$ $[7,11,13]$.

Difficulty: MEDIUM

Solutions:
def solve_min(a, b):
	d_min = [0] * len(a)
	b_index = 0
	for d_index in range(len(a)):
		while a[d_index] > b[b_index]:
			b_index += 1
		d_min[d_index] = b[b_index] - a[d_index]
	return d_min

def solve_max(a, b):
	d_max = [0] * len(a)
	stack = []
	b_index = len(a) - 1
	for d_index in range(len(a) - 1, -1, -1):
		while b_index >= 0 and b[b_index] >= a[d_index]:
			stack.append(b[b_index])
			b_index -= 1
		d_max[d_index] = stack[0] - a[d_index]
		stack.pop()
	return d_max
t = int(input())
for _ in range(t):
	n = int(input())
	a = [int(comp) for comp in input().split(' ')]
	b = [int(comp) for comp in input().split(' ')]
	print(' '.join((str(k) for k in solve_min(a, b))))
	print(' '.join((str(k) for k in solve_max(a, b))))


def ss_min(l, a):
	n = len(l)

	def ceiling_of_element(x):
		start = 0
		end = n - 1
		res = -1
		while start <= end:
			mid = (start + end) // 2
			if a[mid] == x:
				return a[mid]
			elif x > a[mid]:
				start = mid + 1
			else:
				res = mid
				end = mid - 1
		return a[res]
	ans = []
	for x in l:
		ans.append(ceiling_of_element(x) - x)
	return ans

def ss_max(a, b):
	n = len(a)
	t = [True for _ in range(n)]
	for i in range(n - 1, 0, -1):
		if a[i] <= b[i - 1]:
			t[i] = True
		else:
			t[i] = False
	t_t = [i for i in range(n)]
	last_f = n
	for i in range(n - 1, -1, -1):
		t_t[i] = last_f - 1
		if t[i] == False:
			last_f = i
	ans = []
	for i in range(n):
		ans.append(b[t_t[i]] - a[i])
	return ans
for _ in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	b = list(map(int, input().split()))
	ans_min = ss_min(a, b)
	ans_max = ss_max(a, b)
	print(*ans_min)
	print(*ans_max)