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...
The above is tricky. Write me a correct solution in PYTHON3.

=====
Can you provide a 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?
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.

import os, sys, math
from io import BytesIO, IOBase
it = lambda : int(input())
ma = lambda: map(int, input().split(" "))
li = lambda: list(map(int,input().split(" ")))
mod=10**9+7
def main():
    for _ in range(int(input())):
        n=it()
        a=li()
        b=li()
        x=sum(a)
        y=sum(b)
        if x!=y:
            print(-1)
            continue
        dif=[]
        for i in range(n):
            z=a[i]-b[i]
            dif.append([z,i])
        dif.sort()
        m=0
        s=0
        e=n-1
        ans=[]
        while dif[s][0]<0 and e>s:
            if dif[e][0]+dif[s][0]>=0:

                z=-dif[s][0]
                dif[e][0]+=dif[s][0]
                dif[s][0]=0
                val=(dif[e][1]+1,dif[s][1]+1)
                s+=1
                m+=z
                for i in range(z):
                    ans.append(val)
            else:
                dif[s][0]+=dif[e][0]
                z=dif[e][0]
                dif[e][0]=0
                m+=z
                val=(dif[e][1]+1,dif[s][1]+1)
                e-=1
                for i in range(z):
                    ans.append(val)
        print(m)
        for i in range(m):
            print(*ans[i])

        # Fast IO Region
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 readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
       ...