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.math.*;
import java.util.*;
import javafx.util.Pair;

public class Level {

    public static DS.Scanner in = new DS.Scanner();
    public static DS.Print out = new DS.Print();
    public static int[] parent = null;

    public static boolean test(Pair[] p, int a, int b) {
        boolean flg = true;
        for (Pair cur : p) {
            int x = (int) cur.getKey();
            int y = (int) cur.getValue();
            if ((x == a || x == b) || (y == a || y == b)) {
            } else {
                flg = false;
            }
        }
        return flg;
    }

    public static void main(String[] args) {
        int T = in.nextInt();
        while (T-- > 0) {
            int n = in.nextInt();
            N[] a = new N[n];
            int[] b = new int[n];

            boolean x = false;
            boolean y = false;

            for (int i = 0; i < n; i++) {
                int vv = in.nextInt();
                a[i] = new N(vv, y, x);
                if (vv == -1) {
                    y = true;
                } else if (vv == 1) {
                    x = true;
                }

            }
            for (int i = 0; i < n; i++) {
                b[i] = in.nextInt();
            }
            boolean siOk = true;
            for (int i = 0; i < n; i++) {
                int cur = b[i];
                int have = a[i].v;
                if (cur == have); else {
                    if (cur > have) {
                        if (a[i].ii) {
                        } else {
                            siOk = false;
                        }
                    } else {
                        if (a[i].dd) {
                        } else {
                            siOk = false;
                        }
                    }
                }
            }
            if (siOk) {
                System.out.println("YES");
            } else {
                System.out.println("NO");
            }
        }
    }

    public static class N {

        int v = 0;
        boolean dd= false;
        boolean ii = false;

        public N(int val, boolean a, boolean b) {
            v = val;
            dd = a;
            ii = b;
        }
    }

    public static class Algo {

        public static int lowerBound(ArrayList<Long> list, int length, long value) {
            int low = 0;
            int high = length;
            while (low < high) {
                final int mid = (low + high) / 2;
                if (value <= list.get(mid)) {
                    high = mid;
                } else {
                    low = mid + 1;
                }
            }
            return low;
        }

        public static int upperBound(ArrayList<Long> list, int length, long value) {
            int low = 0;
            int high = length;
            while (low < high) {
                final int mid = (low + high) / 2;
                if (value >= list.get(mid)) {
                    low = mid + 1;
                } else {
                    high = mid;
                }
            }
            return low;
        }

        public static void merge(int arr[], int l, int m, int r) {
            int n1 = m - l + 1;
            int n2 = r - m;

            int L[] = new int[n1];
            int R[] = new int[n2];

            for (int i = 0; i < n1; ++i) {
                L[i] = arr[l + i];
            }
            for (int j = 0; j < n2; ++j) {
                R[j] = arr[m + 1 + j];
            }

            int i = 0, j = 0;

            int k = l;
            while (i < n1 && j < n2) {
                if (L[i] <= R[j]) {
                    arr[k] = L[i];
                    i++;
                } else {
                    arr[k] = R[j];
                    j++;
                }
                k++;
            }

            while (i < n1) {
                arr[k] = L[i];
                i++;
                k++;
            }

            while (j < n2) {
                arr[k] = R[j];
                j++;
                k++;
            }
        }

        public static void sort(int arr[], int l, int r) {
            if (l < r) {
                int m = (l + r) / 2;

                sort(arr, l, m);
                sort(arr, m + 1, r);

                merge(arr, l, m, r);
            }
        }

        public static ArrayList<Integer> sieve(int n) {
            long sqr = (long) Math.sqrt(n);
            boolean[] isPrime = new boolean[n + 1];
            for (int i = 0; i <= n; i++) {
                isPrime[i] = true;
            }
            for (int i = 2; i <= sqr; i++) {
                if (isPrime[i]) {
                    for (int p = i * i; p <= n; p += i) {
                        isPrime[p] = false;
                    }
                }
            }
            ArrayList<Integer> list = new ArrayList<Integer>();
            for (int i = 0; i <= n; i++) {
                if (isPrime[i]) {
                    list.add(i);
                }
            }
            list.remove(0);
            list.remove(0);
            return list;
        }

        public static boolean isPrime(long n) {
            boolean res = true;
            List l = sieve((int) Math.sqrt(n));
            for (int i = 0; i < l.size(); i++) {
                int curPrime = (int) l.get(i);
                if (n % curPrime == 0) {
                    res = false;
                    break;
                }
            }
            return res;
        }

        public static ArrayList factorizatin(int n) {

            ArrayList<Integer> list = new ArrayList<Integer>();
            if (n == 1) {
                list.add(1);
                return list;
            } else if (n == 2) {
                list.add(2);
                return list;
            } else {
                if (isPrime(n)) {
                    System.out.println(-1);
                    return null;
                } else {
                    Iterator ptr = sieve((int) Math.sqrt(n)).iterator();
                    if (ptr.hasNext()) {
                        int cur = (int) ptr.next();
                        // System.out.println(cur);
                        while (n != 1) {
                            System.out.println(n);
                            while (n % cur == 0) {
                                list.add(cur);
                                n /= cur;
                            }
                            if (ptr.hasNext()) {
                                cur = (int) ptr.next();
                            }
                            //System.out.println(cur);
                        }
                    }
                    if (n > 2) {
                        list.add(n);
                    }
                }
                return list;
            }
        }

        public static long gcd(long a, long b) {
            if (b == 0) {
                return a;
            } else {
                return gcd(b, a % b);
            }
        }

        public static long lcm(long a, long b) {
            long ab = a * b;
            long gcd = gcd(a, b);
            return ab / gcd;
        }

        public static int bs(int[] z, int k) {
            int res = 0;
            int l = 0;
            int r = z.length - 1;
            int mid = (l + r) / 2;
            while (l <= r) {

                if (z[mid] == k) {
                    res = 1;
                    break;
                }
                if (z[mid] > k) {
                    r = mid - 1;
                } else {
                    l = mid + 1;
                }
                mid = (l + r) / 2;
            }
            return res;
        }

        public static void solve() {
            int n = Integer.parseInt(in.next());
            int target = Integer.parseInt(in.next());
            int[] z = new int[n];
            for (int i = 0; i < n; i++) {
                z[i] = Integer.parseInt(in.next());
            }
            Arrays.sort(z);
            int ptr1 = 0;
            int ptr2 = n - 1;
            int wind = z[ptr1] + z[ptr2];
            if (wind == target) {
                System.out.println(ptr1 + "-" + ptr2);
            } else {
                while (ptr1 < ptr2 && wind != target) {
                    if (wind > target) {
                        wind -= z[ptr2--];
                        wind += z[ptr2];
                    } else {
                        wind -= z[ptr1++];
                        wind += z[ptr1];
                    }
                }
                if ((ptr1 != 0 || ptr2 != n - 1) && ptr2 != ptr1) {
                    System.out.println(ptr1 + "-" + ptr2);
                } else {
                    System.out.println(-1);
                }
            }
        }

        public static void sliding() {
            int n = Integer.parseInt(in.next());
            int k = Integer.parseInt(in.next());
            int[] z = new int[n];
            for (int i = 0; i < n; i++) {
                z[i] = Integer.parseInt(in.next());
            }
            int wind = 0;
            for (int i = 0; i < k; i++) {
                wind += z[i];
            }
            int max = wind;
            for (int i = k; i < n; i++) {
                wind += z[i];
                wind -= z[i - k];
                max = Math.max(max, wind);
            }
            System.out.println(max);
        }

        public static ArrayList<Integer> dd(int n) {
            ArrayList<Integer> list = new ArrayList<Integer>();
            for (int i = 1; i * i <= n; i++) {
                if (n % i == 0) {
                    list.add(n / i);
                    list.add(i);
                }
            }

            return list;
        }
    }

    private static class DS {

        public static class Graph {

            int V;
            ArrayList[] data = null;
            int[] parent = null;

            public Graph(int v) {
                this.V = v + 1;
                this.data = new ArrayList[this.V];
                for (int i = 1; i < V; i++) {
                    this.data[i] = new ArrayList<Pair>();
                }
                parent = new int[v + 1];
                Arrays.fill(parent, -1);
            }

            public void add(int u, int v, int cost) {
                data[u].add(new Pair(v, cost));
                data[v].add(new Pair(u, cost));
            }

            public boolean isConnected(int u, int v) {
                if (data[u].contains(v)) {
                    return true;
                } else {
                    return false;
                }
            }

            public int[] dijkstra(int s) {
                Comparator<Pair> comp = new Comparator<Pair>() {
                    @Override
                    public int compare(Pair t, Pair t1) {
                        return (int) t.getValue() - (int) t1.getValue();
                    }

                };
                PriorityQueue<Pair> q = new PriorityQueue<>(comp);
                int[] cost = new int[this.V];
                Arrays.fill(cost, Integer.MAX_VALUE);
                q.add(new Pair(s, 0));
                cost[s] = 0;
                parent[s] = s;
                while (!q.isEmpty()) {
                    Pair cur = q.poll();
                    int u = (int) cur.getKey();
                    int cst = (int) cur.getValue();
                    ArrayList<Pair> list = data[u];
                    for (Pair p : list) {
                        int d = (int) p.getKey();
                        int curCost = (int) p.getValue();
                        if (cst + curCost <= cost[d]) {
                            parent[d] = u;
                            cost[d] = curCost + cst;
                            q.add(new Pair(d, cost[d]));
                        }
                    }
                }
                return cost;
            }
        }

        public static class Print {

            private final BufferedWriter bw;

            public Print() {
                this.bw = new BufferedWriter(new OutputStreamWriter(System.out));
            }

            public void print(Object object) throws IOException {
                bw.append(object + " ");
            }

            public void println(Object object) throws IOException {
                print(object);
                bw.append("\n");
            }

            public void close() throws IOException {
                bw.close();
            }
        }

        private static class Stack {

            private int Size;
            Node top;
            Node last;

            Stack() {

                Size = 0;
                top = null;
                last = null;
            }

            public int size() {
                return this.Size;
            }

            public void push(Object item) {
                Node node = new Node();
                node.data = item;
                node.next = top;
                top = node;
                Size++;
            }

            public void pop() {
                if (top != null) {
                    top = top.next;
                }
                Size--;
            }

            public boolean isEmpty() {
                return top == null;
            }

            public Object getTop() {
                if (top != null) {
                    return top.data;
                } else {
                    return null;
                }
            }

            public void display() {
                if (top != null) {
                    Node temp = top;
                    while (temp != null) {
                        System.out.print(temp.data + " ");
                        temp = temp.next;
                    }
                    System.out.println();
                }
            }

            private class Node {

                Object data;
                Node next;
            }
        }

        private static class Scanner {

            BufferedReader br;
            StringTokenizer st;

            public Scanner() {
                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 nextInt() {
                return Integer.parseInt(next());
            }

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

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

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

            BigInteger nextBigInteger() {
                return new BigInteger(next());
            }

        }
    }

}
