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

//   package faltu;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
//import java.security.KeyStore.Entry;
import java.util.*;
import java.util.Map.Entry;

public class Main {
    static long LowerBound(long[] a2, long x) { // x is the target value or key
	  int l=-1,r=a2.length;
	  while(l+1<r) {
	    int m=(l+r)>>>1;
	    if(a2[m]>=x) r=m;
	    else l=m;
	  }
	  return r;
	}
    static int UpperBound(int a[], int x) {// x is the key or target value
    int l=-1,r=a.length;
    while(l+1<r) {
       int m=(l+r)>>>1;
       if(a[m]<=x) l=m;
       else r=m;
    }
    return l+1;
 }
    public static long getClosest(long val1, long val2,long target)
	{
		if (target - val1 >= val2 - target)
		return val2;       
		else
		return val1;       
	}
    public static long findClosest(long arr[], long target)
    {
        int n = arr.length;
 
        // Corner cases
        if (target <= arr[0])
            return arr[0];
        if (target >= arr[n - 1])
            return arr[n - 1];
 
        // Doing binary search
        int i = 0, j = n, mid = 0;
        while (i < j) {
            mid = (i + j) / 2;
 
            if (arr[mid] == target)
                return arr[mid];
 
            /* If target is less than array element,
               then search in left */
            if (target < arr[mid]) {
        
                // If target is greater than previous
                // to mid, return closest of two
                if (mid > 0 && target > arr[mid - 1])
                    return getClosest(arr[mid - 1],
                                  arr[mid], target);
                 
                /* Repeat for left half */
                j = mid;             
            }
 
            // If target is greater than mid
            else {
                if (mid < n-1 && target < arr[mid + 1])
                    return getClosest(arr[mid],
                          arr[mid + 1], target);               
                i = mid + 1; // update i
            }
        }
 
        // Only single element left after search
        return arr[mid];
    }
    static void ruffleSort(long[] a) {
		int n=a.length;
		Random r=new Random();
		for (int i=0; i<a.length; i++) {
			long oi=r.nextInt(n), temp=a[i];
			a[i]=a[(int)oi];
			a[(int)oi]=temp;
		}
		Arrays.sort(a);
	}
    static void ruffleSort(int[] a) {
		int n=a.length;
		Random r=new Random();
		for (int i=0; i<a.length; i++) {
			int oi=r.nextInt(n), temp=a[i];
			a[i]=a[oi];
			a[oi]=temp;
		}
		Arrays.sort(a);
	}
    public static int findIndex(long arr[], long t) 
    { 
 
        // if array is Null 
        if (arr == null) { 
            return -1; 
        } 
 
        // find length of array 
        int len = arr.length; 
        int i = 0; 
 
        // traverse in the array 
        while (i < len) {
            if (arr[i] == t) { 
                return i; 
            } 
            else { 
                i = i + 1; 
            } 
        } 
        return -1; 
    }
 
    static long gcd(long a, long b)
    {
        if (a == 0)
            return b; 
        return gcd(b % a, a); 
    }
    static int gcd(int a, int b)
    {
        if (a == 0)
            return b; 
        return gcd(b % a, a); 
    }
    static long lcm(long a, long b)
    {
        return (a / gcd(a, b)) * b;
    }
 
    public static int[] swap(int a[], int left, int right)
    {
        int temp = a[left];
        a[left] = a[right];
        a[right] = temp;
        return a;
    }
    public static void swap(int max0,int max1)
    {
    	int temp=max0;
    	max0=max1;
    	max1=temp;
    }
 
    public static int[] reverse(int a[], int left, int right)
    {
 
        // Reverse the sub-array
        while (left < right) {
            int temp = a[left];
            a[left++] = a[right];
            a[right--] = temp;
        }
        return a;
    }
 
  
    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;
        }
    }
    
//    *******----segement tree implement---******
    
//    -------------START--------------------------
    
    void buildTree (int[] arr,int[] tree,int start,int end,int treeNode)
    {
    	if(start==end)
    	{
    		tree[treeNode]=arr[start];
    		return;
    	}
    	buildTree(arr,tree,start,end,2*treeNode);
    	buildTree(arr,tree,start,end,2*treeNode+1);
    	tree[treeNode]=tree[treeNode*2]+tree[2*treeNode+1];
    }
    void updateTree(int[] arr,int[] tree,int start,int end,int treeNode,int idx,int value)
    {
    	if(start==end)
    	{
    		arr[idx]=value;
    		tree[treeNode]=value;
    		return;
    	}
    	int mid=(start+end)/2;
    	if(idx>mid)
    	{
    		updateTree(arr,tree,mid+1,end,2*treeNode+1,idx,value);
    	}
    	else
    	{
    		updateTree(arr,tree,start,mid,2*treeNode,idx,value);
    	}
    	tree[treeNode]=tree[2*treeNode]+tree[2*treeNode+1];
    }
    	static int[][] dp;
    	private static long getClosetNumberOfTarget(long[] dataArray, long target) {
    		 
    		// Edge case - Check if array length is zero
    		if (dataArray.length == 0)
    			System.exit(1);
    		// Straight case - If target is smaller or equal to first element in array
    		if (target <= dataArray[0])
    			return dataArray[0];
    		// Straight case - If target is greater or equal to last element in array
    		if (target >= dataArray[dataArray.length - 1])
    			return dataArray[dataArray.length - 1];
     
    		// Start binary search algorithm
    		int start = 0;
    		int end = dataArray.length-1;
    		int mid = 0;
     
    		// Keep dividing array till further division is not possible
    		while (end - start != 1) {
    			// Calculate middle index
    			mid = (start + end) / 2;
    			// Check if middle element is equal to target
    			if (target == dataArray[mid])
    				// If yes return middle element as middle element = target 
    				return dataArray[mid];
    			// Check if target is smaller to middle element. If yes, take first half of array including mid
    			if (target < dataArray[mid]) 
    				end = mid;
    			// Check if target is greater to middle element. If yes, take first half of array including mid
    			if (target > dataArray[mid])
    				start = mid;	
    		}
    		// Now you will have only two numbers in array in which target number will fall
    		return Math.abs(target - dataArray[start]) <= Math.abs(target - dataArray[end]) ? dataArray[start]
    				: dataArray[end];
    	}
    	private static int getClosetNumberOfTarget(int[] dataArray, int target) {
    		 
    		// Edge case - Check if array length is zero
    		if (dataArray.length == 0)
    			System.exit(1);
    		// Straight case - If target is smaller or equal to first element in array
    		if (target <= dataArray[0])
    			return dataArray[0];
    		// Straight case - If target is greater or equal to last element in array
    		if (target >= dataArray[dataArray.length - 1])
    			return dataArray[dataArray.length - 1];
     
    		// Start binary search algorithm
    		int start = 0;
    		int end = dataArray.length - 1;
    		int mid = 0;
     
    		// Keep dividing array till further division is not possible
    		while (start < end) {
    			// Calculate middle index
    			mid = (start + end) / 2;
    			// Check if middle element is equal to target
    			if (target == dataArray[mid])
    				// If yes return middle element as middle element = target
    				return dataArray[mid];
    			// Check if target is smaller to middle element. If yes, take first half of
    			// array including mid
    			if (target < dataArray[mid]) {
    				// If target is greater than previous element of middle element, we have reached the deciding range
    				if (target > dataArray[mid - 1])
    					return Math.abs(target - dataArray[mid]) >= Math.abs(target - dataArray[mid - 1]) ? dataArray[mid-1]
    							: dataArray[mid];
    				end = mid - 1;
    			}
    			// Check if target is greater to middle element. If yes, take first half of
    			// array including mid
    			if (target > dataArray[mid]) {
    				// If target is smaller than next element of middle element, we have reached the deciding range
    				if (target < dataArray[mid + 1])
    					return Math.abs(target - dataArray[mid]) <= Math.abs(target - dataArray[mid + 1]) ? dataArray[mid]
    							: dataArray[mid + 1];
     
    				start = mid + 1;
    			}
    		}
    		// after exiting form loop, middle element will be closer
    		return dataArray[mid];
    	}
    	
//    	disjoint set implementation --start
        static void makeSet(int n)
        {
        	parent=new int[n];
        	rank=new int[n];
        	for(int i=0;i<n;i++)
        	{
        		parent[i]=i;
        		rank[i]=0;
        	}
        	
        }
        static void union(int u,int v)
        {
        	u=findpar(u);
        	v=findpar(v);
        	if(rank[u]<rank[v])parent[u]=v;
        	else if(rank[v]<rank[u])parent[v]=u;
        	else 
        	{
//        		System.out.println(v+" "+parent[v]);
        		parent[v]=u;
//        		System.out.println(v+" "+parent[v]);
        		rank[u]++;
        	}
        }
        
    	private static int findpar(int node)
    	{	
    		if(node==parent[node])return node;
    		return parent[node]=findpar(parent[node]);
    	}
    	static int parent[];
        static int rank[];
    	
//    	*************end
    	static long MOD=(long) 1e+7;
        public static void main(String[] args) {
        FastReader s = new FastReader();
          dp=new int[1001][1001];
          long tt = s.nextLong();
          while (tt-->0)
          {  
        	 int n=s.nextInt();
        	 char[][] a=new char[2][n];
        	 for(int i=0;i<2;i++)
        	 {
        		 String st=s.next();
        		 a[i]=st.toCharArray();
        	 }
        	 int count=0;
        	 for(int i=0;i<n;i++)
        	 {
        		 if((a[0][i]=='1')&&(a[1][i]=='1'))
        		 {
        			count++; 
        		 }
        	 }
        	 if(count>0)System.out.println("NO");
        	 else System.out.println("YES");
          }
        	 	       
        }
        static boolean issafe(int i, int j, int r,int c, char ch)
        {
			if (i < 0 || j < 0 || i >= r || j >= c|| ch!= '1')return false;
			else return true;
        }
        static long power(long a, long b)
        {
        	   a %=MOD;
        	    long out = 1;
        	    while (b > 0) {
        	        if((b&1)!=0)out = out * a % MOD;
        	        a = a * a % MOD;
        	        b >>= 1;
        			a*=a;
        	    }
        	    return out;
        }
//        static long power(long x, long y)
//        {
//            long res = 1;     // Initialize result
//          
//            while (y > 0)
//            {
//               
//                // If y is odd, multiply x with result
//                if ((y & 1) != 0)
//                    res = res * x;
//          
//                // y must be even now
//                y = y >> 1; // y = y/2
//                x = x * x;  // Change x to x^2
//            }
//            return res;
//        }

		static boolean check(String str)
        {
            // Compute sum of digits
            int n = str.length();
            int digitSum = 0;
            for (int i=0; i<n; i++)
                digitSum += (str.charAt(i)-'0');
          
            // Check if sum of digits is
            // divisible by 3.
            return (digitSum % 3 == 0);
        }

}
class pair{
	long x,y;
	public pair(long x,long y)
	{
		this.x=x;
		this.y=y;
	}
}



