description: 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).
solution: 
  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'        
  
  
  
  for i in range(a):
      b = inp()
      t = strng()
      z = strng()
      print(solve(t,z))
  
  