human
AquaMoon and Cirno are playing an interesting game with arrays. Cirno has prepared two arrays a and b, both consist of n non-negative integers. AquaMoon can perform the following operation an arbitrary number of times (possibly zero):

  * She chooses two indices i and j (1 ≤ i, j ≤ n), then decreases the i-th element of array a by 1, and increases the j-th element of array a by 1. The resulting values at i-th and j-th index of array a are a_i - 1 and a_j + 1, respectively. Each element of array a must be non-negative after each operation. If i = j this operation doesn't change the array a. 


AquaMoon wants to make some operations to make arrays a and b equal. Two arrays a and b are considered equal if and only if a_i = b_i for all 1 ≤ i ≤ n.

Help AquaMoon to find a sequence of operations that will solve her problem or find, that it is impossible to make arrays a and b equal.

Please note, that you don't have to minimize the number of operations.

Input

The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases.

The first line of each test case contains a single integer n (1 ≤ n ≤ 100).

The second line of each test case contains n integers a_1, a_2, ..., a_n (0 ≤ a_i ≤ 100). The sum of all a_i does not exceed 100.

The third line of each test case contains n integers b_1, b_2, ..., b_n (0 ≤ b_i ≤ 100). The sum of all b_i does not exceed 100.

Output

For each test case print "-1" on the only line if it is impossible to make two arrays equal with some sequence of operations.

Otherwise, print an integer m (0 ≤ m ≤ 100) in the first line — the number of operations. Then print m lines, each line consists of two integers i and j — the indices you choose for the operation.

It can be proven that if it is possible to make two arrays equal with some sequence of operations, there exists a sequence with m ≤ 100.

If there are multiple possible solutions, you can print any.

Example

Input

4
4
1 2 3 4
3 1 2 4
2
1 3
2 1
1
0
0
5
4 3 2 1 0
0 1 2 3...
Using python3 can you solve the prior task?
assistant
#Here is Python program to find a sequence of operations that will solve her problem or find, that it is impossible to make arrays a and b equal.

# python
import os
import sys; import math
from io import BytesIO, IOBase

def main():
    for _ in range(int(input())):
        n = int(input()); m = 0
        a = [int(x) for x in sys.stdin.readline().split()]
        b = [int(x) for x in sys.stdin.readline().split()]
        #ac = a.copy(); bc = b.copy(); ac.sort(); bc.sort(); 
        iarr = []; jarr = []; flag = 0
        if sum(a) != sum(b):
            print(-1); continue
        elif a == b:
            print(0); continue
        else:
            i = 0
            while(i < len(a)):
                if a[i] > b[i]:
                    flag = 1
                    while True:
                        if a[i] == b [i]:
                            break
                        a[i] -= 1
                        j = 0
                        while(j < len(a)):
                            if a[j] < b[j]:
                                a[j] += 1
                                m += 1
                                iarr.append(i+1); jarr.append(j+1)
                                break
                            j += 1
                if flag == 1:
                    flag = 0; i = 0
                else:
                    i += 1
            if a == b:
                print(m)
                for i in range(m):
                    print(iarr[i],jarr[i],sep = " ")
            else:
                print(-1)

# region fastio

BUFSIZE = 8192

class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def...