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.*;
  import static java.lang.System.*;
  import static java.lang.Math.*;
  import static java.util.Collections.*;
  import static java.util.Arrays.*;
  public class A {
      public static int swap(int... args) {
          return args[0];
      } static   ArrayList<Integer> primes = new ArrayList<>();
      //static Scanner sc = new Scanner(System.in);
      static FastReader sc = new FastReader();
      public static void main(String[] args) throws IOException {
          do {
              startTime = currentTimeMillis();
              //setOut(new PrintStream("output"));
              //setIn(new FileInputStream("input"));
              int T = sc.nextInt();while (T-- != 0)
              {
                  solve();
  
              }
              endTime = currentTimeMillis();
              long duration = endTime - startTime;
              //out.println(duration);
              if (false) {
                  out.println(max(3, 2));
                  Integer[] ARRAY = new Integer[2];
                  ArrayList<Integer> LIST = new ArrayList<>();
                  LIST.add(2);
                  // sort(LIST, reverseOrder());
                  LIST.sort(reverseOrder());
                  sort(ARRAY, reverseOrder());
                  out.println(LIST + " " + Arrays.toString(ARRAY));
              }
          } while (LOCAL);
      }
      public static void solve() throws IOException {
  /////////////////////////////////////////////////////////////////////
     int n =sc.nextInt();
     char [][] chars = new char[2][n];
          for (int i = 0; i < 2; i++) {
              String str = sc.next();
              for (int j = 0; j < str.length(); j++) {
                  chars[i][j]=str.charAt(j);
              }
          }
          int i = 0,j=0;
          while (true){
              if(j<n-1&&chars[i][j+1]=='0'){
                  j++;
              }
              else {
                  if(i==0 && j<n-1 && chars[i+1][j+1]=='0'){
                      i=1; j++;
                  }
                  else if(i==1 && j<n-1 && chars[i-1][j+1]=='0'){
                      i=0; j++;
                  }
                  else break;
              }
          }
          if(i==1&&j==n-1){
              yes();
          }
          else if(i==0&&j==n-1){
              if(chars[i+1][j]=='0') yes();
          }
          else no();
  ///////////////////////////////////////////////////////////////////////
  
      }
      public static final boolean LOCAL = System.getProperty("ONLINE_JUDGE")==null;
      // public static final boolean LOCAL = System.getProperty("LOCAL")!=null;
      public static final String ANSI_RED = "\u001B[31m";
      public static final String ANSI_RESET = "\u001B[0m";
      static long startTime;
      static long endTime;
      static boolean[] prime;
      static final int M = (int) 1e9 + 7;
      static final long MM = (long) M * M;
      static final int MAX = Integer.MAX_VALUE;
      static final int MIN = Integer.MIN_VALUE;
      static final int SIZE = (int) 1e9 * 2;
      static int [] visited;
      static ArrayList<ArrayList<Integer>> graph;
      static ArrayList<Integer> topologicalSort;
      static  boolean isCyclic = false;
      static void dfs(int src){
          visited[src] = 1;
          for(Integer integer : graph.get(src) ){
              if(visited[integer]!=1){
                  dfs(integer);
              }
          }
          topologicalSort.add(src);
  
      }
      static void detectCycle(int src){
          visited[src] =2;
          for(Integer integer : graph.get(src)){
              if(visited[integer]==0){
                  detectCycle(integer);
              }
              else if(visited[integer]==2) {
                  isCyclic = true;
                  return;
              }
  
          }
          visited[src] = 1;
      }
      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;
          }
      }
      static class Pair implements Comparable< Pair> {
          private int key;
          private int value;
          public Pair(int key, int value) {
              this.key = key;
              this.value = value;
          }
          public int second() {
              return value;
          }
          @Override
          public int compareTo(Pair o) {
              int val = -Integer.compare(value,  o.value);
              if(val==0){
                  return -Integer.compare(key, o.key);
              }
              return val;
          }
          @Override
          public String toString() {
              return "Pair{" + "x=" + key + ", y=" + value + '}';
          }
      }
      static <Array, Target> int count(Array[] array, Target target){
          int cn=0;
          for (Array value : array) {
              if (value.equals(target)) cn++;
          }
          return cn;
      }
      static int count (String string , char target){
          int cn=0;
          for (int i = 0; i < string.length(); i++) {
              if(string.charAt(i)==target)cn++;
          }
          return cn;
      }
      static  <Array> void revArray(Array [] arr) {
          int n = arr.length;
          for (int i = 0; i < n / 2; i++) {
              Array temp = arr[i];
              arr[i] = arr[n - i - 1];
              arr[n - i - 1] = temp;
          }
  
      }
      static <Array> void printArray(Array [] arr) {
          int n = arr.length;
          for (Array array : arr)out.print(array + " ");
          out.println();
      }
      static void yes() {out.println("YES");}
      static void no() {out.println("NO");}
      public static boolean isPal(String s)
      {
          StringBuilder stringBuilder = new StringBuilder(s);
          return s.equals(stringBuilder.reverse().toString());
      }
      public static int lowerBound(Integer[] array, int length, int value) {
          int low = -1;
          int hi = length;
          while (low + 1 < hi) {
              int mid = (low + hi) / 2;
              if (array[mid] <= value) {
                  low = mid;
              } else {
                  hi = mid;
              }
          }
          return low;
      }
      public static int upperBound(Integer[] array, int length, int value) {
          int low = -1;
          int hi = length;
          while (low + 1 < hi) {
              int mid = (low + hi) >> 1;
              if (array[mid] >= value) {
                  hi = mid;
              } else low = mid;
          }
          return hi;
      }
      public static int binarySearch(Integer[] arr, int length, int value) {
          int low = 0;
          int hi = length - 1;
          int ans = -1;
          while (low <= hi) {
              int mid = (low + hi) >> 1;
              if (arr[mid] > value) {
                  hi = mid - 1;
              } else if (arr[mid] < value) {
                  low = mid + 1;
              } else {
                  ans = mid;
                  break;
              }
          }
          return ans;
      }
      public static int gcd(int a, int b) {
          return b==0?a:gcd(b, a % b);
      }
      public static int lcm(int a, int b) {
          return a / gcd(a, b) * b;
      }
      public static int countDivs(int n) {
          int cn = 0;
          int sqr = (int) Math.sqrt(n);
          for (int i = 1; i <= sqr; ++i) {
              if (n % i == 0) {
                  ++cn;
              }
          }
          cn *= 2;
          if (sqr * sqr == n) cn--;
          return cn;
      }
  
      static void prime(int x) {
          //sieve algorithm. nlog(log(n)).
          prime = new boolean[(x + 1)];
          Arrays.fill(prime, true);
          prime[0] = prime[1] = false;
          for (int i = 2; i * i <= x; i++)
              if (prime[i])
                  for (int j = i * i; j <= x; j += i)
                      prime[j] = false;
      }
      static boolean isEven(long x) {
          return x % 2 == 0;
      }
      static boolean isPrime(long x) {
          boolean flag = true;
          int sqr = (int) Math.sqrt(x);
          if (x < 2) return false;
          for (int i = 2; i <= sqr; i++) {
              if (x % i == 0) {
                  flag = false;
                  break;
              }
          }
          return flag;
      }
  
      static long factorial(long x) {
          long total = 1;
          for (int i = 2; i <= x; i++)
              total = (total * i) % M;
          return total;
      }
  
      static long power(long x, long n) {
          if (n == 0) {
              return 1;
          }
          long pow = power(x, n / 2L);
          if ((n & 1) == 1) {
              return (x * (pow) * (pow));
          }
          return (pow * pow);
      }
      private static <T> String ts(T t) {
          if(t==null) {
              return "null";
          }
          try {
              return ts((Iterable) t);
          }catch(ClassCastException e) {
              if(t instanceof int[]) {
                  String s = Arrays.toString((int[]) t);
                  return "{"+s.substring(1, s.length()-1)+"}";
              }else if(t instanceof long[]) {
                  String s = Arrays.toString((long[]) t);
                  return "{"+s.substring(1, s.length()-1)+"}";
              }else if(t instanceof char[]) {
                  String s = Arrays.toString((char[]) t);
                  return "{"+s.substring(1, s.length()-1)+"}";
              }else if(t instanceof double[]) {
                  String s = Arrays.toString((double[]) t);
                  return "{"+s.substring(1, s.length()-1)+"}";
              }else if(t instanceof boolean[]) {
                  String s = Arrays.toString((boolean[]) t);
                  return "{"+s.substring(1, s.length()-1)+"}";
              }
              try {
                  return ts((Object[]) t);
              }catch(ClassCastException e1) {
                  return t.toString();
              }
          }
      }
      private static <T> String ts(T[] arr) {
          StringBuilder ret = new StringBuilder();
          ret.append("{");
          boolean first = true;
          for(T t: arr) {
              if(!first) {
                  ret.append(", ");
              }
              first = false;
              ret.append(ts(t));
          }
          ret.append("}");
          return ret.toString();
      }
      private static <T> String ts(Iterable<T> iter) {
          StringBuilder ret = new StringBuilder();
          ret.append("{");
          boolean first = true;
          for(T t: iter) {
              if(!first) {
                  ret.append(", ");
              }
              first = false;
              ret.append(ts(t));
          }
          ret.append("}");
          return ret.toString();
      }
      public static void dbg(Object... o) {
          if(LOCAL) {
              System.err.print("Line #"+Thread.currentThread().getStackTrace()[2].getLineNumber()+": [");
              for(int i = 0; i<o.length; i++) {
                  if(i!=0) {
                      System.err.print(", ");
                  }
                  System.err.print(ts(o[i]));
              }
              System.err.println("]");
          }
      }
  
  }
  