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.math.*;
  import java.util.*;
  import java.util.stream.*;
  import java.lang.management.*;
  import static java.lang.Math.*;
  
  @SuppressWarnings("unchecked")
  public class P1598A {
  
    public void run() throws Exception {
  nextT:
      for (int T = nextInt(); T > 0; T--) {
        int n = nextInt();
        String a = next(), b = next();
        boolean [][] ab = new boolean [n][2];
        ab[n - 1][1] = true;
  
        for (int i = n - 2; i >= 0; i--) {
          boolean nab = ab[i + 1][0] | ab[i + 1][1];
          ab[i][0] = (a.charAt(i) == '0') ? nab : false;
          ab[i][1] = (b.charAt(i) == '0') ? nab : false;
        }
  
        println(ab[0][0] ? "YES" : "NO");
      }
    }
  
    public static void main(String... args) throws Exception {
      br = new BufferedReader(new InputStreamReader(System.in));
      pw = new PrintWriter(new BufferedOutputStream(System.out));
      new P1598A().run();
      br.close();
      pw.close();
      System.err.println("\n[Time : " + (System.currentTimeMillis() - startTime) + " ms]");
      long gct = 0, gcc = 0;
      for (GarbageCollectorMXBean garbageCollectorMXBean : ManagementFactory.getGarbageCollectorMXBeans()) {
        gct += garbageCollectorMXBean.getCollectionTime();
        gcc += garbageCollectorMXBean.getCollectionCount();
      }
      System.err.println("[GC time : " + gct + " ms, count = " + gcc + "]");
      System.err.println("[JIT time : " + ManagementFactory.getCompilationMXBean().getTotalCompilationTime() + " ms]");
    }
  
    static long startTime = System.currentTimeMillis();
    static BufferedReader br;
    static PrintWriter pw;
    StringTokenizer stok;
  
    String nextToken() throws IOException {
      while (stok == null || !stok.hasMoreTokens()) {
        String s = br.readLine();
        if (s == null) { return null; }
        stok = new StringTokenizer(s);
      }
      return stok.nextToken();
    }
  
    void print(byte b) { print("" + b); }
    void print(int i) { print("" + i); }
    void print(long l) { print("" + l); }
    void print(double d) { print("" + d); }
    void print(char c) { print("" + c); }
    void print(Object o) {
      if (o instanceof int[]) { print(Arrays.toString((int [])o));
      } else if (o instanceof long[]) { print(Arrays.toString((long [])o));
      } else if (o instanceof char[]) { print(Arrays.toString((char [])o));
      } else if (o instanceof byte[]) { print(Arrays.toString((byte [])o));
      } else if (o instanceof short[]) { print(Arrays.toString((short [])o));
      } else if (o instanceof boolean[]) { print(Arrays.toString((boolean [])o));
      } else if (o instanceof float[]) { print(Arrays.toString((float [])o));
      } else if (o instanceof double[]) { print(Arrays.toString((double [])o));
      } else if (o instanceof Object[]) { print(Arrays.toString((Object [])o));
      } else { print("" + o); }
    }
    void printsp(int [] a) { for (int i = 0, n = a.length; i < n; print(a[i] + " "), i++); }
    void printsp(long [] a) { for (int i = 0, n = a.length; i < n; print(a[i] + " "), i++); }
    void print(String s) { pw.print(s); }
    void println() { println(""); }
    void println(byte b) { println("" + b); }
    void println(int i) { println("" + i); }
    void println(long l) { println("" + l); }
    void println(double d) { println("" + d); }
    void println(char c) { println("" + c); }
    void println(Object o) { print(o); println(); }
    void println(String s) { pw.println(s); }
    int nextInt() throws IOException { return Integer.parseInt(nextToken()); }
    long nextLong() throws IOException { return Long.parseLong(nextToken()); }
    double nextDouble() throws IOException { return Double.parseDouble(nextToken()); }
    char nextChar() throws IOException { return (char) (br.read()); }
    String next() throws IOException { return nextToken(); }
    String nextLine() throws IOException { return br.readLine(); }
    int [] readInt(int size) throws IOException {
      int [] array = new int [size];
      for (int i = 0; i < size; i++) { array[i] = nextInt(); }
      return array;
    }
    long [] readLong(int size) throws IOException {
      long [] array = new long [size];
      for (int i = 0; i < size; i++) { array[i] = nextLong(); }
      return array;
    }
    double [] readDouble(int size) throws IOException {
      double [] array = new double [size];
      for (int i = 0; i < size; i++) { array[i] = nextDouble(); }
      return array;
    }
    String [] readLines(int size) throws IOException {
      String [] array = new String [size];
      for (int i = 0; i < size; i++) { array[i] = nextLine(); }
      return array;
    }
  
    int gcd(int a, int b) {
      if (a == 0) return Math.abs(b); if (b == 0) return Math.abs(a);
      a = Math.abs(a); b = Math.abs(b);
      int az = Integer.numberOfTrailingZeros(a), bz = Integer.numberOfTrailingZeros(b);
      a >>>= az; b >>>= bz;
      while (a != b) {
        if (a > b) { a -= b; a >>>= Integer.numberOfTrailingZeros(a); }
              else { b -= a; b >>>= Integer.numberOfTrailingZeros(b); }
      }
      return (a << Math.min(az, bz));
    }
  
    long gcd(long a, long b) {
      if (a == 0) return Math.abs(b); if (b == 0) return Math.abs(a);
      a = Math.abs(a); b = Math.abs(b);
      int az = Long.numberOfTrailingZeros(a), bz = Long.numberOfTrailingZeros(b);
      a >>>= az; b >>>= bz;
      while (a != b) {
        if (a > b) { a -= b; a >>>= Long.numberOfTrailingZeros(a); }
              else { b -= a; b >>>= Long.numberOfTrailingZeros(b); }
      }
      return (a << Math.min(az, bz));
    }
  
    boolean isPrime(int v) {
      if (v <= 1) { return false; }
      if (v <= 3) { return true; }
      if (((v & 1) == 0) || ((v % 3) == 0)) { return false; }
      for (int m = 5, n = (int)sqrt(v); m <= n; m += 6) { if (((v % m) == 0) || ((v % (m + 2)) == 0)) { return false; } }
      return true;
    }
  
    int [] rshuffle(int [] a) { // RANDOM shuffle
      Random r = new Random();
      for (int i = a.length - 1, j, t; i >= 0; j = r.nextInt(a.length), t = a[i], a[i] = a[j], a[j] = t, i--);
      return a;
    }
  
    int [] qshuffle(int [] a) { // QUICK shuffle
      int m = new Random().nextInt(10) + 2;
      for (int i = 0, n = a.length, j = m % n, t; i < n; t = a[i], a[i] = a[j], a[j] = t, i++, j = (i * m) % n);
      return a;
    }
  
    long [] shuffle(long [] a) {
      Random r = new Random();
      for (int i = a.length - 1; i >= 0; i--) {
        int j = r.nextInt(a.length);
        long t = a[i]; a[i] = a[j]; a[j] = t;
      }
      return a;
    }
  
    void shuffle(Object [] a) {
      Random r = new Random();
      for (int i = a.length - 1; i >= 0; i--) {
        int j = r.nextInt(a.length);
        Object t = a[i]; a[i] = a[j]; a[j] = t;
      }
    }
  
    int [] sort(int [] a) {
      final int SHIFT = 16, MASK = (1 << SHIFT) - 1, SIZE = (1 << SHIFT) + 1;
      int n = a.length, ta [] = new int [n], ai [] = new int [SIZE];
      for (int i = 0; i < n; ai[(a[i] & MASK) + 1]++, i++);
      for (int i = 1; i < SIZE; ai[i] += ai[i - 1], i++);
      for (int i = 0; i < n; ta[ai[a[i] & MASK]++] = a[i], i++);
      int [] t = a; a = ta; ta = t;
      ai = new int [SIZE];
      for (int i = 0; i < n; ai[(a[i] >> SHIFT) + 1]++, i++);
      for (int i = 1; i < SIZE; ai[i] += ai[i - 1], i++);
      for (int i = 0; i < n; ta[ai[a[i] >> SHIFT]++] = a[i], i++);
      return ta;
    }
  
    boolean nextPerm(int [] a) {
      int j, i = a.length - 2;
      for (; (i >= 0) && (a[i] > a[i + 1]); i--);
      if (i >= 0) {
        for (j = a.length - 1; a[i] > a[j]; j--);
        a[i] ^= a[j]; a[j] ^= a[i]; a[i] ^= a[j]; // swap(a[i], a[j])
        for (int l = i + 1, r = a.length - 1; l < r; l++, r--) {
          a[l] ^= a[r]; a[r] ^= a[l]; a[l] ^= a[r]; // swap(a[r], a[l])
        }
      }
      return (i >= 0);
    }
  
    void flush() {
      pw.flush();
    }
  
    void pause() {
      flush(); System.console().readLine();
    }
  }