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.BufferedReader;
  import java.io.IOException;
  import java.io.InputStreamReader;
  import java.util.ArrayList;
  import java.util.Collections;
  import java.util.StringTokenizer;
  
  
  public class A {
  
  	public static void main(String[] args)
      {
          FastReader s=new FastReader();
          int t = s.nextInt();         // Number of test cases
          for (int i = 0; i<t; i++) {
          	int n = s.nextInt();
          	int[][] arr = new int[2][n];
          	String str1 = s.next();
          	String str2 = s.next();
          	for (int j = 0; j<str1.length(); j++) {
          		char ch = str1.charAt(j);
          		arr[0][j] = ch-'0';
          	}
          	for (int j = 0; j<str2.length(); j++) {
          		char ch = str2.charAt(j);
          		arr[1][j] = ch-'0';
          	}
          	int row = 0;
          	int col = 0;
          	boolean flag = false;
          	while (row != 1 || col != n-1) {
          		int inrow = row;
          		int incol = col;
          		if (row+1<=1 && arr[row+1][col] == 0) {
          			arr[row][col] = 1;
          			row = row+1;
          			col = col;
          		}else if (row-1>=0 && arr[row-1][col] == 0) {
          			arr[row][col] = 1;
          			row = row-1;
          			col = col;
          		}else if (col+1<=n-1 && arr[row][col+1] == 0) {
          			arr[row][col] = 1;
          			col = col+1;
          			row = row;
          		}else if (col-1>=0 && arr[row][col-1] == 0) {
          			arr[row][col] = 1;
          			col = col-1;
          			row = row;
          		}else if (row+1<=1 && col+1<=n-1 && arr[row+1][col+1] == 0) {
          			arr[row][col] = 1;
          			row = row+1;
          			col = col+1;
          		}else if (row-1>=0 && col+1<=n-1 && arr[row-1][col+1] == 0) {
          			arr[row][col] = 1;
          			row = row-1;
          			col = col + 1;
          		}
  //        		System.out.println(row + "  " + col);
          		if (row == inrow && col == incol) {
          			System.out.println("No");
          			flag = true;
          			break;
          		}
          	}
          	if (flag == false)System.out.println("Yes");
          }
  
          
          
  
          
          
      }
      
      
      
      
      
      
      
      
      
      
      
      static void sort(int[] a) {
      	ArrayList<Integer> l = new ArrayList<>();
      	for (int i : a) l.add(i);
      	Collections.sort(l);
      	for (int i = 0; i<a.length; i++) {
      		a[i]=l.get(i);
      	}
      }
      
      
      /* .......................pair.............................. */
  	 static class pair implements Comparable<pair>{
  	    	int slotNo;
  	    	int diff;
  	    	int index;
  	    	public pair (int slotNo, int diff, int index) {
  	    		this.slotNo = slotNo;
  	    		this.diff = diff;
  	    		this.index = index;
  	    	}
  	    	public int compareTo(pair o) {
  	    		return this.diff-o.diff;                  // minimum element at peek
  	    	}
  	    }
  	    
  	    
     
     
  
  	   
  		/* .......................lower/upper bound.............................. */
  		 // Return index for just greater element, independent of "k" exist or not
  		 // Can be used to find last occurance of an element (duplicates present)
  			static int upper(long A[], long k, int si, int ei) { // First True
  				int l = si;
  				int u = ei;
  
  				while (l < u) {
  					int mid =  l + ((u-l) / 2);
  					if (k < A[mid]) {
  						u = mid;
  					} else {
  						l = mid+1;
  					}
  				}
  				if (A[l] >= k) return l;                     // returns index
  				return l+1;
  			}
  
  			// Return first occurance if element exist, if not then return index of next greater element
  			// Can be used to find first occurance of element (duplicates present)
  		static int lower(long A[], long k, int si, int ei) { // First True
  			int l = si;
  			int u = ei;
  
  			while (l < u) {
  				int mid =  l + ((u-l) / 2);
  				if (k <= A[mid]) {
  					u = mid;
  				} else {
  					l = mid+1;
  				}
  			}
  			if (A[l] >= k) return l;                     // returns index
  			return l+1;
  		}
  	   
      
      
  		/* .......................GCD.............................. */
  		// Worst time complexity: log(n). 
  		// We can find minimum fraction of two numbers(a,b) = a/b = (a/gcd(a,b))/(b/gcd(a,b))
  		// Ex: let's take one number x=2, and other y. Maxm number of times y gets divided is log(y)
  		public static int gcd(int x, int y) {   // x smaller than y
  			if (y < x) return gcd(y,x);
  			
  			if (y%x == 0) return x;
  			return gcd(y%x, x);
  //			int common = 1;
  //			for (int div = 2; div<=x; div++) {
  //				while (x%div == 0 && y%div == 0) {
  //					common *= div;
  //					x = x/div;
  //					y = y/div;
  //					return common;
  //				}
  //			}
  //			return common;
  		}
  		
  		
  		
  	static class FastReader
      {
          BufferedReader br;
          StringTokenizer st;
   
          public FastReader()
          {
              br = new BufferedReader(new
                       InputStreamReader(System.in));
          }
   
          String next()
          {
              while (st == null || !st.hasMoreElements())
              {
                  try
                  {
                      st = new StringTokenizer(br.readLine());
                  }
                  catch (IOException  e)
                  {
                      e.printStackTrace();
                  }
              }
              return st.nextToken();
          }
   
          int nextInt()
          {
              return Integer.parseInt(next());
          }
   
          long nextLong()
          {
              return Long.parseLong(next());
          }
   
          double nextDouble()
          {
              return Double.parseDouble(next());
          }
   
          String nextLine()
          {
              String str = "";
              try
              {
                  str = br.readLine();
              }
              catch (IOException e)
              {
                  e.printStackTrace();
              }
              return str;
          }
      }
  }
  