Once again, Boris needs the help of Anton in creating a task. This time Anton needs to solve the following problem:

There are two arrays of integers a and b of length n. It turned out that array a contains only elements from the set \{-1, 0, 1\}.

Anton can perform the following sequence of operations any number of times:

  1. Choose any pair of indexes (i, j) such that 1 ≤ i < j ≤ n. It is possible to choose the same pair (i, j) more than once. 
  2. Add a_i to a_j. In other words, j-th element of the array becomes equal to a_i + a_j. 



For example, if you are given array [1, -1, 0], you can transform it only to [1, -1, -1], [1, 0, 0] and [1, -1, 1] by one operation.

Anton wants to predict if it is possible to apply some number (zero or more) of these operations to the array a so that it becomes equal to array b. Can you help him?

Input

Each test contains multiple test cases. 

The first line contains the number of test cases t (1 ≤ t ≤ 10000). The description of the test cases follows.

The first line of each test case contains a single integer n (1 ≤ n ≤ 10^5) — the length of arrays.

The second line of each test case contains n integers a_1, a_2, ..., a_n (-1 ≤ a_i ≤ 1) — elements of array a. There can be duplicates among elements.

The third line of each test case contains n integers b_1, b_2, ..., b_n (-10^9 ≤ b_i ≤ 10^9) — elements of array b. There can be duplicates among elements.

It is guaranteed that the sum of n over all test cases doesn't exceed 10^5.

Output

For each test case, output one line containing "YES" if it's possible to make arrays a and b equal by performing the described operations, or "NO" if it's impossible.

You can print each letter in any case (upper or lower).

Example

Input


5
3
1 -1 0
1 1 -2
3
0 1 1
0 2 2
2
1 0
1 41
2
-1 0
-1 -41
5
0 1 -1 1 -1
1 1 -1 1 -1


Output


YES
NO
YES
YES
NO

Note

In the first test-case we can choose (i, j)=(2, 3) twice and after that choose (i, j)=(1, 2) twice too. These operations will transform [1, -1, 0] → [1, -1, -2] → [1, 1, -2]

In the second test case we can't make equal numbers on the second position.

In the third test case we can choose (i, j)=(1, 2) 41 times. The same about the fourth test case.

In the last lest case, it is impossible to make array a equal to the array b.
import java.io.*;
import java.lang.reflect.Parameter;
import java.nio.charset.IllegalCharsetNameException;
import java.util.*;

public class Solution {
    public static void main(String[] args) throws IOException {
        OutputStream outputStream = System.out;
        FastReader in = new FastReader();
        OutputWriter out = new OutputWriter(outputStream);
        Taska solver=  new Taska();
        solver.solve(in,out);
        out.close();
    }
}
class Taska{
    public void solve(FastReader in,OutputWriter out) {
        int t=in.ni();
        while (t-->0){
            int n=in.ni();
            int[] a= new int[n];
            int[] b= new int[n];
            for(int i=0; i<n;i++){
                a[i]=in.ni();
            }
            for(int i=0; i<n;i++){
                b[i]=in.ni();
            }
            if(a[0]!=b[0]){
                out.println("NO");
            }
            else {
                boolean neg=false;
                boolean pos= false;
                boolean flag= true;
                if(a[0]<0){
                    neg=true;
                }
                else if(a[0]>0) {
                    pos=true;
                }
                for(int i=1 ;i<n;i++){
                    if((b[i]-a[i])>0 && !pos){
                        flag=false;
                        break;
                    }
                    else if((b[i]-a[i])<0 && !neg){
                        flag=false;
                        break;
                    }
                    else {
                        if(a[i]<0){
                            neg=true;
                        }
                        else if(a[i]>0) {
                            pos= true;
                        }
                    }
                }
                if(flag){
                    out.println("YES");
                }
                else {
                    out.println("NO");
                }
            }
        }
    }
}
class StringAlgorithm{
    public ArrayList<Integer> KMP(int[] text, int[] pat){
        ArrayList<Integer> res= new ArrayList<>();
        int[] lps=  lps(pat);
        int i=0;
        int j=0;
        int n=text.length;
        int m=pat.length;
        while(i<n){
            if(pat[j]==text[i]){
                i++;
                j++;
            }
            if(j==m){
                res.add(i-j);
                j=lps[j-1];
            }
            else if(i<n && pat[j]!=text[i]){
                if(j!=0){
                    j=lps[j-1];
                }
                else {
                    i=i+1;
                }
            }
        }
        return res;
    }
    public int[] lps(int[] pat){
        int[] ar= new int[pat.length];
        int len=0;
        int i=1;
        ar[0]=0;
        while(i<pat.length){
            if(pat[i]==pat[len]){
                len++;
                ar[i]=len;
                i++;
            }
            else{
                if(len!=0){
                    len= ar[len-1];
                }
                else {
                    ar[i]=0;
                    i++;
                }
            }
        }
        return ar;
    }
}
class FastReader {
    BufferedReader br;
    StringTokenizer st;

    FastReader() {
        br = new BufferedReader(new InputStreamReader(System.in));
    }

    String next() {
        while (st == null || !st.hasMoreElements()) {
            try {
                st = new StringTokenizer(br.readLine());
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return st.nextToken();
    }

    int ni() {
        return Integer.parseInt(next());
    }

    long nl() {
        return Long.parseLong(next());
    }

    double nd() {
        return Double.parseDouble(next());
    }

    String nLine() {
        String str = "";
        try {
            str = br.readLine();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return str;

    }

}
class OutputWriter extends PrintWriter {

    public OutputWriter(OutputStream outputStream) {
        super(new BufferedWriter(new OutputStreamWriter(outputStream)));
    }

}
class Pair<U, V> {
    final U first;
    final V second;
    Pair(U first, V second) {
        this.first = first;
        this.second = second;
    }
    @Override
    public boolean equals(Object o) {
        if (this == o)
            return true;
        if (o == null || getClass() != o.getClass())
            return false;
        Pair<?, ?> pair = (Pair<?, ?>) o;
        if (!first.equals(pair.first))
            return false;
        return second.equals(pair.second);
    }

    @Override
    public int hashCode() {
        return 31 * first.hashCode() + second.hashCode();
    }

    @Override
    public String toString() {
        return "(" + first + ", " + second + ")";
    }
    public static <U, V> Pair <U, V> of(U a, V b) {
        return new Pair<>(a, b);
    }

}