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: //
  // Source code recreated from a .class file by IntelliJ IDEA
  // (powered by Fernflower decompiler)
  //
  
  import java.io.*;
  import java.util.*;
  
  public class CFA {
      static CFA.Reader sc = new CFA.Reader();
      static BufferedWriter bw;
  
      static long count = 0;
  
      public CFA() {
      }
  
      static boolean flag = false;
  
      public static void main(String[] args) throws IOException {
          Scanner sc = new Scanner(System.in);
          int t = sc.nextInt();
         process: for (int i = 0; i < t; i++) {
              flag=false;
              int n = sc.nextInt();
              String s1 = sc.next();
              String s2 = sc.next();
              char[][] ar = new char[2][n];
              for (int j = 0; j < n; j++) {
                  ar[0][j] = s1.charAt(j);
                  ar[1][j] = s2.charAt(j);
              }
             for(int j=0;j<n;j++){
                 if(j+1<n){
                     if(ar[0][j+1]=='1'&&ar[1][j+1]=='1'){
                         System.out.println("NO");
                         continue process;
                     }
                 }
             }
             System.out.println("YES");
  
  
  
          }
  
  
          bw.flush();
          bw.close();
      }
  
      static void dfs(int i, int j, int n, char[][] ar, boolean[][] reached) {
         // reached[i][j] = true;
          //System.out.println(i +" "+j);
          if(i>=2||j>=n){
              return;
          }
          if (i == 1 && j == (n - 1)) {
              flag = true;
              return;
          }
          if (i + 1 < 2) {
              if (ar[i + 1][j] == '0' && !reached[i + 1][j]) {
                  reached[i][j] = true;
                  dfs(i + 1, j, n, ar, reached);
                  reached[i][j] = false;
              }
          }
          if (j + 1 < n) {
              if (ar[i][j + 1] == '0' && !reached[i][j + 1]) {
                  reached[i][j] = true;
                  dfs(i, j + 1, n, ar, reached);
                  reached[i][j] = false;
              }
          }
          if (i + 1 < 2 && j + 1 < n) {
              if (ar[i + 1][j + 1] == '0' && !reached[i + 1][j + 1]) {
                  reached[i][j] = true;
                  dfs(i + 1, j + 1, n, ar, reached);
                  reached[i][j] = false;
              }
          }
          if (i - 1 >= 0) {
              if (ar[i - 1][j] == '0' && !reached[i - 1][j]) {
                  reached[i][j] = true;
                  dfs(i - 1, j, n, ar, reached);
                  reached[i][j] = false;
              }
          }
         /* if (j + 1 < n) {
              if (ar[i][j + 1] == '0' && !reached[i][j + 1]) {
                  reached[i][j] = true;
                  dfs(i, j + 1, n, ar, reached);
                  reached[i][j] = false;
              }
          }*/
          if (i - 1 >= 0 && j + 1 < n) {
              if (ar[i - 1][j + 1] == '0' && !reached[i - 1][j + 1]) {
                  reached[i][j] = true;
                  dfs(i - 1, j + 1, n, ar, reached);
                  reached[i][j] = false;
              }
          }
  
      }
  
      public static class Timings {
          int arr, dept;
  
          public Timings(int arr, int dept) {
              this.arr = arr;
              this.dept = dept;
          }
      }
  
      static void merge(long arr[], int l, int m, int r) {
          int s1 = m - l + 1;
          int s2 = r - (m + 1) + 1;
          long[] ar1 = new long[s1];
          long[] ar2 = new long[s2];
          for (int i = 0; i < s1; i++) {
              ar1[i] = arr[l + i];
          }
          for (int i = 0; i < s2; i++) {
              ar2[i] = arr[m + 1 + i];
          }
          int ind = l;
          int i = 0, j = 0;
          while (i < s1 && j < s2) {
              if (ar1[i] < ar2[j]) {
                  arr[ind] = ar1[i];
                  i++;
  
              } else if (ar1[i] == ar2[j]) {
                  arr[ind] = ar1[i];
                  i++;
              } else {
                  arr[ind] = ar2[j];
                  j++;
                  count += (m + 1) - (l + i);
              }
              ind++;
          }
          while (i < s1) {
              arr[ind] = ar1[i];
              i++;
              ind++;
              //count++;
          }
          while (j < s2) {
              arr[ind] = ar2[j];
              j++;
              ind++;
          }
          //System.out.println(count);
  
      }
  
      static void mergeSort(long arr[], int l, int r) {
          //code here
          if (r > l) {
              int mid = l + (r - l) / 2;
              mergeSort(arr, l, mid);
              mergeSort(arr, mid + 1, r);
              merge(arr, l, mid, r);
  
          }
      }
  
      public static int checker(int a) {
          if (a % 2 == 0) {
              return 1;
          } else {
              byte b;
              do {
                  b = 2;
              } while (a + b != (a ^ b));
  
              return b;
          }
      }
  
      public static boolean checkPrime(int n) {
          if (n != 0 && n != 1) {
              for (int j = 2; j * j <= n; ++j) {
                  if (n % j == 0) {
                      return false;
                  }
              }
  
              return true;
          } else {
              return false;
          }
      }
  
      public static void dfs1(List<List<Integer>> g, boolean[] visited, Stack<Integer> stack, int num) {
          visited[num] = true;
          Iterator var4 = ((List) g.get(num)).iterator();
  
          while (var4.hasNext()) {
              Integer integer = (Integer) var4.next();
              if (!visited[integer]) {
                  dfs1(g, visited, stack, integer);
              }
          }
  
          stack.push(num);
      }
  
      public static void dfs2(List<List<Integer>> g, boolean[] visited, List<Integer> list, int num, int c, int[] raj) {
          visited[num] = true;
          Iterator var6 = ((List) g.get(num)).iterator();
  
          while (var6.hasNext()) {
              Integer integer = (Integer) var6.next();
              if (!visited[integer]) {
                  dfs2(g, visited, list, integer, c, raj);
              }
          }
  
          raj[num] = c;
          list.add(num);
      }
  
      public static int inputInt() throws IOException {
          return sc.nextInt();
      }
  
      public static long inputLong() throws IOException {
          return sc.nextLong();
      }
  
      public static double inputDouble() throws IOException {
          return sc.nextDouble();
      }
  
      public static String inputString() throws IOException {
          return sc.readLine();
      }
  
      public static void print(String a) throws IOException {
          bw.write(a);
      }
  
      public static void printSp(String a) throws IOException {
          bw.write(a + " ");
      }
  
      public static void println(String a) throws IOException {
          bw.write(a + "\n");
      }
  
      public static long getAns(int[] ar, int c, long[][] dp, int i, int sign) {
          if (i < 0) {
              return 1L;
          } else if (c <= 0) {
              return 1L;
          } else {
              dp[i][c] = Math.max(dp[i][c], Math.max((long) ar[i] * getAns(ar, c - 1, dp, i - 1, sign), getAns(ar, c, dp, i - 1, 1)));
              return dp[i][c];
          }
      }
  
      public static long power(long a, long b, long c) {
          long ans;
          for (ans = 1L; b != 0L; b /= 2L) {
              if (b % 2L == 1L) {
                  ans *= a;
                  ans %= c;
              }
  
              a *= a;
              a %= c;
          }
  
          return ans;
      }
  
      public static long power1(long a, long b, long c) {
          long ans;
          for (ans = 1L; b != 0L; b /= 2L) {
              if (b % 2L == 1L) {
                  ans = multiply(ans, a, c);
              }
  
              a = multiply(a, a, c);
          }
  
          return ans;
      }
  
      public static long multiply(long a, long b, long c) {
          long res = 0L;
  
          for (a %= c; b > 0L; b /= 2L) {
              if (b % 2L == 1L) {
                  res = (res + a) % c;
              }
  
              a = (a + a) % c;
          }
  
          return res % c;
      }
  
      public static long totient(long n) {
          long result = n;
  
          for (long i = 2L; i * i <= n; ++i) {
              if (n % i == 0L) {
                  while (n % i == 0L) {
                      n /= i;
                  }
  
                  result -= result / i;
              }
          }
  
          if (n > 1L) {
              result -= result / n;
          }
  
          return result;
      }
  
      public static long gcd(long a, long b) {
          return b == 0L ? a : gcd(b, a % b);
      }
  
      public static boolean[] primes(int n) {
          boolean[] p = new boolean[n + 1];
          p[0] = false;
          p[1] = false;
  
          int i;
          for (i = 2; i <= n; ++i) {
              p[i] = true;
          }
  
          for (i = 2; i * i <= n; ++i) {
              if (p[i]) {
                  for (int j = i * i; j <= n; j += i) {
                      p[j] = false;
                  }
              }
          }
  
          return p;
      }
  
      public String LargestEven(String S) {
          int[] count = new int[10];
  
          int num;
          for (num = 0; num < S.length(); ++num) {
              ++count[S.charAt(num) - 48];
          }
  
          num = -1;
  
          for (int i = 0; i <= 8; i += 2) {
              if (count[i] > 0) {
                  num = i;
                  break;
              }
          }
  
          StringBuilder ans = new StringBuilder();
  
          for (int i = 9; i >= 0; --i) {
              int j;
              if (i != num) {
                  for (j = 1; j <= count[i]; ++j) {
                      ans.append(i);
                  }
              } else {
                  for (j = 1; j <= count[num] - 1; ++j) {
                      ans.append(num);
                  }
              }
          }
  
          if (num != -1 && count[num] > 0) {
              ans.append(num);
          }
  
          return ans.toString();
      }
  
      static {
          bw = new BufferedWriter(new OutputStreamWriter(System.out));
  
      }
  
      public static class Score {
          int l;
          String s;
  
          public Score(int l, String s) {
              this.l = l;
              this.s = s;
          }
      }
  
      public static class Ath {
          int r1;
          int r2;
          int r3;
          int r4;
          int r5;
          int index;
  
          public Ath(int r1, int r2, int r3, int r4, int r5, int index) {
              this.r1 = r1;
              this.r2 = r2;
              this.r3 = r3;
              this.r4 = r4;
              this.r5 = r5;
              this.index = index;
          }
      }
  
      static class Reader {
          private final int BUFFER_SIZE = 65536;
          private DataInputStream din;
          private byte[] buffer;
          private int bufferPointer;
          private int bytesRead;
  
          public Reader() {
              this.din = new DataInputStream(System.in);
              this.buffer = new byte[65536];
              this.bufferPointer = this.bytesRead = 0;
          }
  
          public Reader(String file_name) throws IOException {
              this.din = new DataInputStream(new FileInputStream(file_name));
              this.buffer = new byte[65536];
              this.bufferPointer = this.bytesRead = 0;
          }
  
          public String readLine() throws IOException {
              byte[] buf = new byte[64];
  
              int cnt;
              byte c;
              for (cnt = 0; (c = this.read()) != -1 && c != 10; buf[cnt++] = (byte) c) {
              }
  
              return new String(buf, 0, cnt);
          }
  
          public int nextInt() throws IOException {
              int ret = 0;
  
              byte c;
              for (c = this.read(); c <= 32; c = this.read()) {
              }
  
              boolean neg = c == 45;
              if (neg) {
                  c = this.read();
              }
  
              do {
                  ret = ret * 10 + c - 48;
              } while ((c = this.read()) >= 48 && c <= 57);
  
              return neg ? -ret : ret;
          }
  
          public long nextLong() throws IOException {
              long ret = 0L;
  
              byte c;
              for (c = this.read(); c <= 32; c = this.read()) {
              }
  
              boolean neg = c == 45;
              if (neg) {
                  c = this.read();
              }
  
              do {
                  ret = ret * 10L + (long) c - 48L;
              } while ((c = this.read()) >= 48 && c <= 57);
  
              return neg ? -ret : ret;
          }
  
          public double nextDouble() throws IOException {
              double ret = 0.0D;
              double div = 1.0D;
  
              byte c;
              for (c = this.read(); c <= 32; c = this.read()) {
              }
  
              boolean neg = c == 45;
              if (neg) {
                  c = this.read();
              }
  
              do {
                  ret = ret * 10.0D + (double) c - 48.0D;
              } while ((c = this.read()) >= 48 && c <= 57);
  
              if (c == 46) {
                  while ((c = this.read()) >= 48 && c <= 57) {
                      ret += (double) (c - 48) / (div *= 10.0D);
                  }
              }
  
              return neg ? -ret : ret;
          }
  
          private void fillBuffer() throws IOException {
              this.bytesRead = this.din.read(this.buffer, this.bufferPointer = 0, 65536);
              if (this.bytesRead == -1) {
                  this.buffer[0] = -1;
              }
  
          }
  
          private byte read() throws IOException {
              if (this.bufferPointer == this.bytesRead) {
                  this.fillBuffer();
              }
  
              return this.buffer[this.bufferPointer++];
          }
  
          public void close() throws IOException {
              if (this.din != null) {
                  this.din.close();
              }
          }
      }
  }
  