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.io.*;
  import java.util.*;
  
  public class Main {
  
  //	static boolean[] prime = new boolean[10000000];
  	final static long mod = 1000000007; 
  
  	public static void main(String[] args) {
  //		sieve();
  		InputReader in = new InputReader(System.in);
  		PrintWriter out = new PrintWriter(System.out);
  		
  		int t = in.nextInt();
  		
  		while(t-- > 0) {
  			int n = in.nextInt();
  			char[][] a = new char[2][];
  			a[0] = in.next().toCharArray();
  			a[1] = in.next().toCharArray();
  			boolean ans = true;
  			for(int i = 0; i < n; i++) {
  				if(a[0][i] == '1' && a[1][i] == '1') {
  					ans = false;
  					break;
  				}
  			}
  			out.println(ans ? "YES" : "NO");
  		}
  		
  		out.flush();
  	}
  	
  	static long gcd(long a, long b) {
  		if (a % b == 0) {
  			return b;
  		} else {
  			return gcd(b, a % b);
  		}
  	}
  
  	static void reverseArray(int[] a) {
  		for (int i = 0; i < (a.length >> 1); i++) {
  			int temp = a[i];
  			a[i] = a[a.length - 1 - i];
  			a[a.length - 1 - i] = temp;
  		}
  	}
  
  	static int[] intInput(int n, InputReader in) {
  		int[] a = new int[n];
  		for (int i = 0; i < a.length; i++)
  			a[i] = in.nextInt();
  		return a;
  	}
  
  	static long[] longInput(int n, InputReader in) {
  		long[] a = new long[n];
  		for (int i = 0; i < a.length; i++)
  			a[i] = in.nextLong();
  		return a;
  	}
  
  	static String[] strInput(int n, InputReader in) {
  		String[] a = new String[n];
  		for (int i = 0; i < a.length; i++)
  			a[i] = in.next();
  		return a;
  	}
  
  //	static void sieve() {
  //		for (int i = 2; i * i < prime.length; i++) {
  //			if (prime[i])
  //				continue;	
  //			for (int j = i * i; j < prime.length; j += i) {
  //				prime[j] = true;
  //			}
  //		}
  //	}
  
  }
  
  class Data {
  	long val;
  	int ind;
  
  	Data(long val, int ind) {
  		this.val = val;
  		this.ind = ind;
  	}
  }
  
  class Node {
  	int val;
  	ArrayList<Node> c;
  
  	Node(int val) {
  		this.val = val;
  		c = new ArrayList<>();
  	}
  }
  
  class compareVal implements Comparator<Data> {
  
  	@Override
  	public int compare(Data o1, Data o2) {
  		return (int)(o1.val - o2.val);
  	}
  
  }
  
  class compareInd implements Comparator<Data> {
  
  	@Override
  	public int compare(Data o1, Data o2) {
  		return o1.ind - o2.ind;
  	}
  
  }
  
  class InputReader {
  	public BufferedReader reader;
  	public StringTokenizer tokenizer;
  
  	public InputReader(InputStream stream) {
  		reader = new BufferedReader(new InputStreamReader(stream), 32768);
  		tokenizer = null;
  	}
  
  	public String next() {
  		while (tokenizer == null || !tokenizer.hasMoreTokens()) {
  			try {
  				tokenizer = new StringTokenizer(reader.readLine());
  			} catch (IOException e) {
  				throw new RuntimeException(e);
  			}
  		}
  		return tokenizer.nextToken();
  	}
  
  	public int nextInt() {
  		return Integer.parseInt(next());
  	}
  
  	long nextLong() {
  		return Long.parseLong(next());
  	}
  
  	double nextDouble() {
  		return Double.parseDouble(next());
  	}
  
  	String nextLine() {
  		String str = "";
  		try {
  			str = reader.readLine();
  		} catch (IOException e) {
  			e.printStackTrace();
  		}
  		return str;
  	}
  
  }