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.
/*
    Created by vasu090 on 2:31 AM, 28 Jan, 2021
    Copyright © 2020 vasu090.
    All rights reserved.
*/
#include <iostream>
#include <cmath>
#include <vector>
#include <algorithm>
#include <cstring>
#include <map>
#include <set>
#include <numeric>
#include <cassert>

using namespace std;

#define rep(i, a, b) for(auto (i)=a;(i)<(b);(i)++)
#define list(i, N) for(auto (i)=0;(i)<(N);(i)++)
#define ALL(a) (a).begin(),(a).end()
#define RALL(a) (a).rbegin(),(a).rend()
#define SZ(x) (int)(x).size()
#define vt vector
#define error(x) cout << #x << " = " << (x) << '\n'
#define trav(a, x) for(auto& (a): (x))
#define UNIQUE(x) (x).resize(distance((x).begin(),unique(ALL(x))))

typedef long long ll;
typedef vector<ll> vi;
typedef pair<ll, ll> pi;
#define mp make_pair
#define pb push_back
#define eb emplace_back

#define int ll
#define INF int(1e18+5)
#define mod 1000000007
#define hash_mod 23333333377 //prime number

void setIO(const string &name = "") {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);

    if (name.length()) {
        freopen((name + ".in").c_str(), "r", stdin);
        freopen((name + ".out").c_str(), "w", stdout);
    }
}

template<typename T>
void read(vector<T> &a) {
    for (auto &x: a) cin >> x;
}

template<typename T>
void read(vector<T> &a, int n) {
    a.resize(n);
    for (auto &x: a) cin >> x;
}

template<class T, class U>
ostream &operator<<(ostream &out, const pair<T, U> &v) {
    out << "(";
    out << v.first << "," << v.second;
    return out << ")";
}

template<class T>
ostream &operator<<(ostream &out, const vector<T> &v) {
    out << "[";
    list(i, SZ(v)) {
        if (i) out << ", ";
        out << v[i];
    }
    return out << "]";
}

template<typename T>
void print(vector<T> &a) {
    for (const auto &x: a) cout << x << ' ';
    cout << '\n';
}

void MOD(int &x, int m = mod) {
    x %= m;
    if (x < 0) x += m;
}

#define trace(...) dbg(#__VA_ARGS__, __VA_ARGS__)

template<typename T>
void dbg(const char *name, T &&arg1) {
    cout << name << " : " << arg1 << '\n';
}

template<typename T, typename... U>
void dbg(const char *names, T &&arg1, U &&... args) {
    const char *comma = strchr(names + 1, ',');
    cout.write(names, comma - names) << " : " << arg1 << " | ";
    dbg(comma + 1, args...);
}

template<class T>
void read(T &x) {
    cin >> x;
}

template<class T, class... U>
void read(T &t, U &... u) {
    read(t);
    read(u...);
}

int gcd(int a, int b) { return !a ? b : gcd(b % a, a); }

#define N 1004
int n;
vt<string> b1, b2;

void solve(){
    read(n);
    read(b1,n);
    read(b2,n);

    if(n == 1){
        cout << "YES\n";
        return;
    }

    int changed[n][n];
    list(i,n){
        list(j,n){
            changed[i][j] = (b1[i][j] != b2[i][j]);
        }
    }

    set<int> first, second;
    list(i,n){
        if(changed[0][i]) first.insert(i);
        else second.insert(i);
    }

    if(SZ(first) == n or SZ(second) == n){
        bool good_c = true;
        list(i,n){
            int cnt = 0;
            list(j,n){
                cnt += changed[i][j];
            }
            if(cnt != 0 and cnt != n){
                good_c = false;
                break;
            }
        }
        if(good_c){
            cout << "YES\n";
        }else {
            cout << "NO\n";
        }
        return;
    }

    vt<bool> cur_c;
    bool good = true;
    rep(i,1,n){
        int ff_cnt = 0, ss_cnt = 0;
        list(j,n){
            if(changed[i][j]){
                if(first.count(j)){
                    ff_cnt++;
                }else {
                    assert(second.count(j));
//                    if(!second.count(j)){
//                        good = false;
//                        break;
//                    }
                    ss_cnt++;
                }
            }
        }

        if(ff_cnt and ss_cnt){
            good = false;
            break;
        }
        if(ff_cnt == 0 and ss_cnt == 0){
            good = false;
            break;
        }
        if(ff_cnt < SZ(first) and ff_cnt > 0){
            good = false;
            break;
        }
        if(ss_cnt < SZ(second) and ss_cnt > 0){
            good = false;
            break;
        }

        assert(ff_cnt > 0 or ss_cnt > 0);
    }

    if(good){
        cout << "YES\n";
    }else {
        cout << "NO\n";
    }
}

int32_t main() {
    setIO();

    int t;
    cin >> t;
    while(t--){
        solve();
    }

    return 0;
}