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).
The above is tricky. Write me a correct solution in PYTHON3.
assistant
#Here is Python program to determine if it is possible to complete the level.

#!/usr/bin/env python
from __future__ import division, print_function
from collections import defaultdict, deque
import heapq
import os
import copy 
import sys
from io import BytesIO, IOBase
from typing import Counter, DefaultDict, Deque, OrderedDict
import bisect, math, time

if sys.version_info[0] < 3:
    from __builtin__ import xrange as range
    from future_builtins import ascii, filter, hex, map, oct, zip
from math import ceil, log2
MOD = 1000000007
def power(x,y):
    if y == 0:
        return 1
    if x == 0:
        return 0
    temp = power(x, y//2)
    if (y % 2 == 0):
        return temp * temp % MOD
    else:
        return x * temp * temp % MOD
def solve(i,j,grid, visit):
    n = len(grid[0])
    if i>1 or i<0 or j>n-1 or j<0 or grid[i][j]=='1'or (i,j) in visit:
        return False
    if i==1 and j==n-1:
        return True
    visit.add((i,j))
    return solve(i+1, j, grid, visit) or solve(i, j+1, grid, visit) or solve(i+1, j+1, grid, visit) or solve(i-1, j+1, grid, visit)

def main():
    t = int(input())
    while t:
        n = int(input())
        r1 = str(input())
        r2 = str(input())
        grid = []
        grid.append(r1)
        grid.append(r2)
        visit = set()
        if solve(0,0,grid, visit): print('YES')
        else: print('NO')
        t -= 1
                

# region fastio

BUFSIZE = 8192

class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b =...