human
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).
Using python3 can you solve the prior task?
 ... Give me a Python code to determine if it is possible to complete the level?
assistant
#Here is Python code to determine if it is possible to complete the level.

import sys
import io,os
from io import BytesIO, IOBase
#
from os import path


# def inp():
#     return(int(input()))
# def inlt():
#     return(list(map(int,input().split())))
# def insr():
#     s = input()
#     return(list(s[:len(s) - 1]))
# def invr():
#     return(map(int,input().split()))
# import numpy as np
from collections import Counter
import math
import random
import bisect
from functools import reduce
from sys import stdin,stdout
from math import gcd,floor,sqrt,log
from collections import defaultdict as dd
from bisect import bisect_left as bl,bisect_right as br

if(path.exists('input.txt')):
    sys.stdin = open("input.txt","r")
    sys.stdout = open("output.txt","w")
else:
    input = sys.stdin.readline
    # input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline


sys.setrecursionlimit(100000000)

inp    =lambda: int(input())
strng  =lambda: input().strip()
jn     =lambda x,l: x.join(map(str,l))
strl   =lambda: list(input().strip())
mul    =lambda: map(int,input().strip().split())
mulf   =lambda: map(float,input().strip().split())
seq    =lambda: list(map(int,input().strip().split()))

ceil   =lambda x: int(x) if(x==int(x)) else int(x)+1
ceildiv=lambda x,d: x//d if(x%d==0) else x//d+1

flush  =lambda: stdout.flush()
stdstr =lambda: stdin.readline()
stdint =lambda: int(stdin.readline())
stdpr  =lambda x: stdout.write(str(x))

mod=1000000007

a = inp()

def gcd(a,b):
    if (b == 0):
        return a
    else:
         return gcd (b, a % b)

def gcdofList(A): 
    res = A[0]
    for c in A[1::]:
        res = gcd(res , c) 
        if res == 1:
            return res
            break

    return res         
    pass

def solve(t,z):
    t=  list(t)
    z = list(z)
    #0 0 0
    #0 0 0
    #

    #0 1 2 3
    #0 1 1 1

    #0 1 2 3
    #1 1 1 0

    t_con = Counter(t)
    z_con = Counter(z)

    if '1' not in t_con or '1' not in z_con:
        return 'YES'

    for i in range(1,len(t)-1):
        if t[i] == '1' and z[i] == '1':
            return 'NO'

    return 'YES'       ...