You are given two binary square matrices a and b of size n × n. A matrix is called binary if each of its elements is equal to 0 or 1. You can do the following operations on the matrix a arbitrary number of times (0 or more): 

  * vertical xor. You choose the number j (1 ≤ j ≤ n) and for all i (1 ≤ i ≤ n) do the following: a_{i, j} := a_{i, j} ⊕ 1 (⊕ — is the operation [xor](https://en.wikipedia.org/wiki/Exclusive_or) (exclusive or)). 
  * horizontal xor. You choose the number i (1 ≤ i ≤ n) and for all j (1 ≤ j ≤ n) do the following: a_{i, j} := a_{i, j} ⊕ 1. 



Note that the elements of the a matrix change after each operation.

For example, if n=3 and the matrix a is: $$$ \begin{pmatrix} 1 & 1 & 0 \\\ 0 & 0 & 1 \\\ 1 & 1 & 0 \end{pmatrix} $$$ Then the following sequence of operations shows an example of transformations: 

  * vertical xor, j=1. $$$ a= \begin{pmatrix} 0 & 1 & 0 \\\ 1 & 0 & 1 \\\ 0 & 1 & 0 \end{pmatrix} $$$ 
  * horizontal xor, i=2. $$$ a= \begin{pmatrix} 0 & 1 & 0 \\\ 0 & 1 & 0 \\\ 0 & 1 & 0 \end{pmatrix} $$$ 
  * vertical xor, j=2. $$$ a= \begin{pmatrix} 0 & 0 & 0 \\\ 0 & 0 & 0 \\\ 0 & 0 & 0 \end{pmatrix} $$$ 



Check if there is a sequence of operations such that the matrix a becomes equal to the matrix b.

Input

The first line contains one integer t (1 ≤ t ≤ 1000) — the number of test cases. Then t test cases follow.

The first line of each test case contains one integer n (1 ≤ n ≤ 1000) — the size of the matrices.

The following n lines contain strings of length n, consisting of the characters '0' and '1' — the description of the matrix a.

An empty line follows.

The following n lines contain strings of length n, consisting of the characters '0' and '1' — the description of the matrix b.

It is guaranteed that the sum of n over all test cases does not exceed 1000.

Output

For each test case, output on a separate line: 

  * "YES", there is such a sequence of operations that the matrix a becomes equal to the matrix b; 
  * "NO" otherwise. 



You can output "YES" and "NO" in any case (for example, the strings yEs, yes, Yes and YES will be recognized as positive).

Example

Input


3
3
110
001
110

000
000
000
3
101
010
101

010
101
010
2
01
11

10
10


Output


YES
YES
NO

Note

The first test case is explained in the statements.

In the second test case, the following sequence of operations is suitable: 

  * horizontal xor, i=1; 
  * horizontal xor, i=2; 
  * horizontal xor, i=3; 



It can be proved that there is no sequence of operations in the third test case so that the matrix a becomes equal to the matrix b.
//package div3;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.*;

public class board
{
    static class FastReader
    {
        BufferedReader br;
        StringTokenizer st;

        public 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 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;
        }
    }


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

    // method to return LCM of two numbers
    static long lcm(long a, long b)
    {
        return (a / gcd(a, b)) * b;
    }
    static void sieveOfEratosthenes(int n)
    {
        // Create a boolean array "prime[0..n]" and initialize
        // all entries it as true. A value in prime[i] will
        // finally be false if i is Not a prime, else true.

        for(int i=0;i<n;i++)
            prime[i] = true;

        for(int p = 2; p*p <=n; p++)
        {
            // If prime[p] is not changed, then it is a prime
            if(prime[p] == true)
            {
                // Update all multiples of p
                for(int i = p*p; i <= n; i += p)
                    prime[i] = false;
            }
        }


    }
    static boolean[] prime;

    static int UpperBound(long a[], long x) {// x is the key or target value
        int lo = 0, hi = a.length;
        int ans = hi+1;
        while(lo < hi) {
            int mid = (lo + hi)/2;
            if(x<a[mid])
                hi = mid;
            else if(x == a[mid]){
                ans = mid;
                lo = mid + 1;
            }
            else lo = mid+1;
        }
        return Math.min(ans,lo);
    }
    static int mod = (int)(1e9+7);
    static long binomialCoeff(int n, int k)
    {
        long C[] = new long[k + 1];

        // nC0 is 1
        C[0] = 1;

        for (int i = 1; i <= n; i++) {
            // Compute next row of pascal
            // triangle using the previous row
            for (int j = Math.min(i, k); j > 0; j--)
                C[j] = (C[j]%mod + C[j - 1]%mod)%mod;
        }
        return C[k];
    }
    public static boolean check(int[][] a,int[][] b,Set<Integer> flipColIds){

        int n = a.length;
        int[][] changed = new int[n][n];
        for(int row=0;row<n;row++){
            for(int col=0;col<n;col++){
                int x = ((flipColIds.contains(col))?(a[row][col]^1):a[row][col]);
                changed[row][col] = x;
            }
        }
        for(int row=1;row<n;row++){
            // check for row flip
            boolean eq=true,flipeq=true;
            for(int col=0;col<n;col++){
                eq = eq&(((b[row][col]^changed[row][col]) == 0));
                flipeq = flipeq&(((b[row][col]^changed[row][col]) == 1));
            }
            if(!eq && !flipeq) return false;
        }
        return true;
    }
    public static void main(String[] args)
    {
        FastReader sc=new FastReader();
        PrintWriter out = new PrintWriter(System.out);
        int t = sc.nextInt();

        while(t-->0) {
           int n = sc.nextInt();
           int[][] a = new int[n][n];
           int[][] b = new int[n][n];
           for(int i=0;i<n;i++){
               String s = sc.nextLine();
               for(int j=0;j<n;j++){
                   a[i][j] = s.charAt(j)-'0';
               }
           }
           sc.nextLine();
            for(int i=0;i<n;i++){
                String s  = sc.nextLine();
                for(int j=0;j<n;j++){
                    b[i][j] = s.charAt(j)-'0';
                }
            }
            boolean ok = false;
            for(int loopId=1;loopId<=2;loopId++){
                Set<Integer> flipColIds = new HashSet<>();
                for(int i=0;i<n;i++){
                    if((a[0][i]^b[0][i]) == 1) flipColIds.add(i);
                    //flip first row
                    a[0][i] ^= 1;
                }
                if(check(a,b,flipColIds)){
                    ok = true; break;
                }
            }
            if(ok)out.println("YES");
            else out.println("NO");

        }
        out.close();
    }


}