Monocarp is playing a computer game. Now he wants to complete the first level of this game.

A level is a rectangular grid of 2 rows and n columns. Monocarp controls a character, which starts in cell (1, 1) — at the intersection of the 1-st row and the 1-st column.

Monocarp's character can move from one cell to another in one step if the cells are adjacent by side and/or corner. Formally, it is possible to move from cell (x_1, y_1) to cell (x_2, y_2) in one step if |x_1 - x_2| ≤ 1 and |y_1 - y_2| ≤ 1. Obviously, it is prohibited to go outside the grid.

There are traps in some cells. If Monocarp's character finds himself in such a cell, he dies, and the game ends.

To complete a level, Monocarp's character should reach cell (2, n) — at the intersection of row 2 and column n.

Help Monocarp determine if it is possible to complete the level.

Input

The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases. Then the test cases follow. Each test case consists of three lines.

The first line contains a single integer n (3 ≤ n ≤ 100) — the number of columns.

The next two lines describe the level. The i-th of these lines describes the i-th line of the level — the line consists of the characters '0' and '1'. The character '0' corresponds to a safe cell, the character '1' corresponds to a trap cell.

Additional constraint on the input: cells (1, 1) and (2, n) are safe.

Output

For each test case, output YES if it is possible to complete the level, and NO otherwise.

Example

Input


4
3
000
000
4
0011
1100
4
0111
1110
6
010101
101010


Output


YES
YES
NO
YES

Note

Consider the example from the statement.

In the first test case, one of the possible paths is (1, 1) → (2, 2) → (2, 3).

In the second test case, one of the possible paths is (1, 1) → (1, 2) → (2, 3) → (2, 4).

In the fourth test case, one of the possible paths is (1, 1) → (2, 2) → (1, 3) → (2, 4) → (1, 5) → (2, 6).
1
9
000000010
000000000
 1
9
000000010
000100000
 1
60
000000000000000000000000000000000000000000000000000000000010
000000000000000000000000000000000000000000000000000000000010

YES
 YES
 NO

#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>

using namespace std;
using namespace __gnu_pbds;
#define _setIO() ios::sync_with_stdio(0); cin.tie(0);
template<class T> using ordered_set = tree<T, null_type, less_equal<T>, rb_tree_tag, tree_order_statistics_node_update>;
/* *oset.find_by_order(index_in_set) :: ret element*/

#define ll long long int
#define ld long double
constexpr ll INF = 2e18;
constexpr ld EPS = 1e-9;
constexpr ll mod = 1000000007;
typedef pair<int,int> p32;
typedef pair<ll,ll> p64;

/* _SIEVE_PRIME_FLAG */
int vis[(int)1e6+10];
set<int> primeSet;
void prime_flag(){
for(int i=2; i<(int)1e6+1; i++)
    {if(vis[i]==0){primeSet.insert(i);for(int j=i; j<=1e6; j+=i){vis[j]=1;}}}
}

/*_SORT_FLAG*/
template<typename ty>
bool isrt(vector<ty> v){ 
    if(is_sorted(v.begin(),v.end()) == true)
        return true;
    else return false;}

/*(_BASE, _POW, #mod)*/
long long fastP(long long a, long long b, long long modulus){long long res = 1;while (b > 0){
        if (b & 1)
            res = (res * a) % modulus;
        a = (a * a) % modulus;b = b >> 1;}return res;}

/* _CHECK_PERFECT_SQUARE_FLAG */
bool check_PS(long long n){ 
    double sqrt_n = sqrt(n);if(sqrt_n == int(sqrt_n)){return true;}else{return false;}
}

#define pb push_back
#define inp(type,vec) type x;cin>>x;vec.pb(x); 
#define inc(i,x,n) for(ll i=x;i<n;i++)
#define dec(i,x,n) for(ll i=x;i>=n;i--)
#define step(TC) ll TC;cin>>TC;while(TC--)
#define im INT_MAX
#define in INT_MIN
#define upBound(arr,x) upper_bound(arr.begin(),arr.end(),x)
#define loBound(arr,x) lower_bound(arr.begin(),arr.end(),x)

struct Node{int data;Node *left;Node *right;};
struct node{ll data; node *next; node *prev;};
mt19937 rng;
int getRandomNumber(int l, int r)
{uniform_int_distribution<int> dist(l, r); return dist(rng);}
template<typename T>
void printa(T arr[],ll n){inc(i,0,n){cout<<arr[i]<<" ";}cout<<"\n";}
int __lcm(int a, int b){return (a * b) / __gcd(a, b);}

#define v(x,name) vector<x> name
#define sum(v) accumulate(v.begin(), v.end(), 0)
#define reverse(v) reverse(v.begin(),v.end())
#define sort(v) sort(v.begin(),v.end())
#define digits(n) floor(log10(n)) + 1
#define printv(ar) for(auto x:ar){cout<<x<<" ";}cout<<endl;

/*void init_code(){freopen("input.txt", "r", stdin);freopen("output.txt", "w", stdout);}*/

#define one_built_ll(n) __builtin_popcountll(n)
#define one_built_int(n) __builtin_popcount(n)

#define mx_ele(dyn) *max_element(dyn.begin(),dyn.end())  
#define mn_ele(dyn) *min_element(dyn.begin(),dyn.end())  
#define mset(arr,x) memset(arr,x,sizeof(arr))

/*-----start-----*/

void solve(){
    //generateCases
    step(TC){
        ll n;
        cin>>n;
        char m[2][n];
        inc(i,0,2){
            inc(j,0,n){
                cin>>m[i][j];
            }
        }
        bool kr = true;
        inc(i,0,n-1){
            if(m[0][i] == '1' and m[0][i+1] == '1' and m[1][i+1] == '1' and m[1][i]=='1'){
                kr=false;
            }
        }
        if(kr==true){
            cout<<"YES\n";
        }
        else{
            cout<<"NO\n";
        }
    }
}
int main(){
    _setIO()
    solve();
}