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 java.util.*;
  
  //import javax.naming.directory.NoSuchAttributeExce/ption;
  
  //import sun.security.krb5.internal.EncKDCRepPart;/
  
  //import sun.text.resources.cldr.ext.FormatData_fy;
  
  import java.io.*;
  
  public class Solution {
  	 static FastScanner scr=new FastScanner();
  //		static Scanner scr=new Scanner(System.in);
  		 static PrintStream out=new PrintStream(System.out);
  		 static StringBuilder sb=new StringBuilder();
  		 static  class FastScanner {
  			 BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  			StringTokenizer st=new StringTokenizer("");
  		 	String next() {
  		 		while (!st.hasMoreTokens())
  		 			try {
  		 				st=new StringTokenizer(br.readLine());
  		 			} catch (IOException e) {
  		 				e.printStackTrace();
  		 			}
  		 			return st.nextToken();
  			} long gcd(long a,long b){
  				if(b==0) {
  					return a;
  				}
  					
  				return gcd(b,a%b);
  			}
  		 	 long modPow(long base,long exp) {
  				if(exp==0) {
  					return 1;
  				}
  				if(exp%2==0) {
  					long res=(modPow(base,exp/2));
  					return (res*res);
  				}
  				return (base*modPow(base,exp-1));
  			}
  			long []reverse(long[] count){
  				long b[]=new long[count.length];
  				int index=0;
  				for(int i=count.length-1;i>=0;i--) {
  					b[index++]=count[i];
  				}
  				return b;
  			}
  			int nextInt() {
  				return Integer.parseInt(next());
  			}
  			long getMax(long a[],int n) {
  				long max=Long.MIN_VALUE;
  				for(int i=0;i<n;i++) {
  					max=Math.max(a[i], max);
  				}
  					return max;
  			}
  			long[] readLongArray(int n) {
  				long  [] a=new long  [n];
  				for (int i=0; i<n; i++) a[i]=nextLong();
  				return a;
  			}int[] readArray(int n) {
  				int  [] a=new int  [n];
  				for (int i=0; i<n; i++) a[i]=nextInt();
  				return a;
  			}
  			long nextLong() {
  				return Long.parseLong(next());
  			}
  			
  		}
  
  		 static class triplet{
  			long x;
  			long y;
  			long z;
  			triplet(long x,long y,long z){
  				this.x=x;
  				this.y=y;
  				this.z=z;
  			}
  		} 
  		 static class pair{
  				int x;
  				int y;
  				pair( int x,int y){
  					this.x=x;
  					this.y=y;
  				}
  		 }
  		 static Solve s=new Solve();
  		public static  void main(String []args) {
  			int t=scr.nextInt();
  //			int t=1;
  			while(t-->0) {
  				s.solve();
  			}
  			out.println(sb);
  		}
  		static class Solve{
  			int MAX=Integer.MAX_VALUE;
  			int MIN=Integer.MIN_VALUE;
  			ArrayList<Integer>list[];
  			ArrayList<Integer>a=new ArrayList<>();
  			long mod=998244353;
  			HashMap<Integer,Integer>hm=new HashMap<>();
  			void solve() {
  				int n=scr.nextInt();
  				char c[][]=new char[2][n];
  				
  				for(int i=0;i<2;i++) {
  					String ele=scr.next();
  					c[i]=ele.toCharArray();
  				}
  				
  				boolean good=true;
  				for(int i=0;i<n;i++) {
  					if(c[0][i]=='1' && c[1][i]=='1') {
  						good=false;
  					}
  				}
  				
  				String s=(good)?"YES":"NO";
  				out.println(s);
  			}
  		}
  }
  