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.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Collections;
import java.util.StringTokenizer;


public class A {

	public static void main(String[] args)
    {
        FastReader s=new FastReader();
        int t = s.nextInt();         // Number of test cases
        for (int i = 0; i<t; i++) {
        	int n = s.nextInt();
        	int[][] arr = new int[2][n];
        	String str1 = s.next();
        	String str2 = s.next();
        	for (int j = 0; j<str1.length(); j++) {
        		char ch = str1.charAt(j);
        		arr[0][j] = ch-'0';
        	}
        	for (int j = 0; j<str2.length(); j++) {
        		char ch = str2.charAt(j);
        		arr[1][j] = ch-'0';
        	}
        	int row = 0;
        	int col = 0;
        	boolean flag = false;
        	while (row != 1 && col != n-1) {
        		int inrow = row;
        		int incol = col;
        		if (row+1<=1 && arr[row+1][col] == 0) {
        			arr[row][col] = 1;
        			row = row+1;
        			col = col;
        		}else if (row-1>=0 && arr[row-1][col] == 0) {
        			arr[row][col] = 1;
        			row = row-1;
        			col = col;
        		}else if (col+1<=n-1 && arr[row][col+1] == 0) {
        			arr[row][col] = 1;
        			col = col+1;
        			row = row;
        		}else if (col-1>=0 && arr[row][col-1] == 0) {
        			arr[row][col] = 1;
        			col = col-1;
        			row = row;
        		}else if (row+1<=1 && col+1<=n-1 && arr[row+1][col+1] == 0) {
        			arr[row][col] = 1;
        			row = row+1;
        			col = col+1;
        		}else if (row-1>=0 && col+1<=n-1 && arr[row-1][col+1] == 0) {
        			arr[row][col] = 1;
        			row = row-1;
        			col = col + 1;
        		}
        		
        		if (row == inrow && col == incol) {
        			System.out.println("No");
        			flag = true;
        			break;
        		}
        	}
        	if (flag == false)System.out.println("Yes");
        }

        
        

        
        
    }
    
    
    
    
    
    
    
    
    
    
    
    static void sort(int[] a) {
    	ArrayList<Integer> l = new ArrayList<>();
    	for (int i : a) l.add(i);
    	Collections.sort(l);
    	for (int i = 0; i<a.length; i++) {
    		a[i]=l.get(i);
    	}
    }
    
    
    /* .......................pair.............................. */
	 static class pair implements Comparable<pair>{
	    	int slotNo;
	    	int diff;
	    	int index;
	    	public pair (int slotNo, int diff, int index) {
	    		this.slotNo = slotNo;
	    		this.diff = diff;
	    		this.index = index;
	    	}
	    	public int compareTo(pair o) {
	    		return this.diff-o.diff;                  // minimum element at peek
	    	}
	    }
	    
	    
   
   

	   
		/* .......................lower/upper bound.............................. */
		 // Return index for just greater element, independent of "k" exist or not
		 // Can be used to find last occurance of an element (duplicates present)
			static int upper(long A[], long k, int si, int ei) { // First True
				int l = si;
				int u = ei;

				while (l < u) {
					int mid =  l + ((u-l) / 2);
					if (k < A[mid]) {
						u = mid;
					} else {
						l = mid+1;
					}
				}
				if (A[l] >= k) return l;                     // returns index
				return l+1;
			}

			// Return first occurance if element exist, if not then return index of next greater element
			// Can be used to find first occurance of element (duplicates present)
		static int lower(long A[], long k, int si, int ei) { // First True
			int l = si;
			int u = ei;

			while (l < u) {
				int mid =  l + ((u-l) / 2);
				if (k <= A[mid]) {
					u = mid;
				} else {
					l = mid+1;
				}
			}
			if (A[l] >= k) return l;                     // returns index
			return l+1;
		}
	   
    
    
		/* .......................GCD.............................. */
		// Worst time complexity: log(n). 
		// We can find minimum fraction of two numbers(a,b) = a/b = (a/gcd(a,b))/(b/gcd(a,b))
		// Ex: let's take one number x=2, and other y. Maxm number of times y gets divided is log(y)
		public static int gcd(int x, int y) {   // x smaller than y
			if (y < x) return gcd(y,x);
			
			if (y%x == 0) return x;
			return gcd(y%x, x);
//			int common = 1;
//			for (int div = 2; div<=x; div++) {
//				while (x%div == 0 && y%div == 0) {
//					common *= div;
//					x = x/div;
//					y = y/div;
//					return common;
//				}
//			}
//			return common;
		}
		
		
		
	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;
        }
    }
}
