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

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);
    }
    static void path(int index1, int index2, char [] [] maze,int n){
        if(index2+1<n&&maze[index1][index2+1]=='0'){
            path(index1,index2+1,maze,n);
        }
       else if(index2+1<n&&index1+1==1 && maze[index1+1][index2+1]=='0'){
            path(1,index2+1,maze,n);
        }
       else if(index2+1<n&&index1+1==2 && maze[index1-1][index2+1]=='0'){
            path(0, index2+1,maze,n);
        }
       else if(maze[(index1+1)%2][index2]=='0'){
           maze[(index1)%2][index2] = '1';
           path((index1+1)%2,index2,maze,n);
        }
        else if(index1==1 && index2==n-1){
            yes();
        }
        else no();

    }
    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);
            }
        }
        path(0,0,chars,n);
///////////////////////////////////////////////////////////////////////

    }
    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("]");
        }
    }

}
