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).
1
9
000000010
000000000
 1
9
000000010
000100000
 1
60
000000000000000000000000000000000000000000000000000000000010
000000000000000000000000000000000000000000000000000000000010

YES
 YES
 NO

//
// 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'&&ar[0][j]=='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();
            }
        }
    }
}
