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: //package codechef;
  
  import java.io.DataInputStream;
  import java.io.FileInputStream;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.PrintWriter;
  import java.net.Inet4Address;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.Collections;
  import java.util.Comparator;
  import java.util.Deque;
  import java.util.HashMap;
  import java.util.HashSet;
  import java.util.LinkedList;
  import java.util.Map;
  import java.util.PriorityQueue;
  import java.util.Queue;
  import java.util.Set;
  import java.util.Stack;
  import java.util.TreeMap;
  
  
  
  
  
  
  public class cp_2 {
  	static int mod=(int)1e9+7;
  	
  //		static  Reader sc=new Reader();
  	   static FastReader sc=new FastReader(System.in);
  	 
  	
  	public static void main(String[] args) throws IOException {
  		// TODO Auto-generated method stub
  		//FastReader sc=new FastReader();
  			long tc=sc.nextLong();
  //		int tc=1;
  			while(tc-->0)
  			{
  
  				int n=sc.nextInt();
  				char mat[][]=new char[2][n];
  				for(int i=0;i<2;i++)
  				{
  					mat[i]=sc.next().toCharArray();
  				}
  				int i=0,j=0;
  				boolean falg=true;
  				int xAdd[]= {1,-1,0,1};
  				int yAdd[]= {1,1,1,0};
  				while(i<2 && j<n )
  				{
  					boolean flag2=false;
  					for(int k=0;k<4;k++)
  					{
  						int x=i+xAdd[k];
  						int y=j+yAdd[k];
  						if(x>=0 && x<2 && y>=0 && y<n)
  						{
  							if(mat[x][y]!='1')
  							{
  								i=x;j=y;
  								flag2=true;
  								break;
  							}
  						}
  						
  					}
  					if (!flag2) {
  						falg=false;
  						break;
  					}
  					if(i==1 && j==n-1)
  						break;
  				}
  				
  				if (falg) {
  					out.println("YES");
  				}
  				else {
  					out.println("NO");
  				}
  				
  
  				
  			}
  			
  			out.flush();
  			out.close();
  			System.gc();
  	
  	}
  	
  	
  	
  
  
  	/*
  	   ...SOLUTION ENDS HERE...........SOLUTION ENDS HERE...
   */
  	
  	
  	
  	
  	static class fwt
  	{
  		int n;
  		long BITree[];
  		fwt(int n)
  		{
  			this.n=n;
  			BITree=new long[n+1];
  		}
  		
  		fwt(int arr[], int n)
  		{
  			this.n=n;
  			BITree=new long[n+1];
  			for(int i = 0; i < n; i++)
  			updateBIT(n, i, arr[i]);
  		 }
  		
  		   long getSum(int index)
  		   {
  		       long sum = 0;
  		       index = index + 1;
  		       while(index>0)
  		       {
  		           sum += BITree[index];
  		           index -= index & (-index);
  		       }
  		       return sum;
  		   }
  		   void updateBIT(int n, int index,int val)
  		   {
  		       index = index + 1;
  		       while(index <= n)
  		       {
  		       BITree[index] += val;
  		       index += index & (-index);
  		       }
  		   }
  		   void print()
  		   {
  			    for(int i=0;i<n;i++)
  			    out.print(getSum(i)+" ");
  			    out.println();
  		   }
  	}
  
  	
  	
  	
  	
  	
  	
  	static int setBitNumber(long n)
      {
          if (n == 0)
              return 0;
   
          int msb = 0;
          n = n / 2;
   
          while (n != 0) {
              n = n / 2;
              msb++;
          }
   
          return msb;
      }
   
  	
  	
  	static int getFirstSetBitPos(long n)
      {
          return (int)((Math.log10(n & -n)) / Math.log10(2)) + 1;
      }
  	
  	
  	static ArrayList<Integer> primes;
  	static boolean prime[];
  	static void sieveOfEratosthenes(int n)
      {
          // Create a boolean array
          // "prime[0..n]" and
          // initialize all entries
          // it as true. A value in
          // prime[i] will finally be
          // false if i is Not a
          // prime, else true.
         prime= new boolean[n + 1];
          for (int i = 2; i <= n; i++)
              prime[i] = true;
          
          for (int p = 2; p * p <= n; p++)
          {
              // If prime[p] is not changed, then it is a
              // prime
              if (prime[p] == true)
              {
                  // Update all multiples of p
                  for (int i = p * p; i <= n; i += p)
                      prime[i] = false;
              }
          }
   
          // Print all prime numbers
          for (int i = 2; i <= n; i++)
          {
              if (prime[i] == true)
                 primes.add(i);
          }
      }
  	
  	
  	
  	static long mod(long a, long b) {
  		  long c = a % b;
  		  return (c < 0) ? c + b : c;
  		}
  	
  	static void swap(long arr[],int i,int j)
  	{
  		long temp=arr[i];
  		arr[i]=arr[j];
  		arr[j]=temp;
  	}
  
  	
  	
  	static boolean util(int a,int b,int c)
  	{
  		if(b>a)util(b, a, c);
  		
  		while(c>=a)
  		{
  			c-=a;
  			if(c%b==0)
  				return true;
  		}
  		
  		
  		return (c%b==0);
  	}
  	
  	static boolean check(char arr[][], int i,int j)
  	{
  		int cnt=0;
  		for(int k=i;k<i+2;k++)
  		{
  			for(int l=j;l<j+2;l++)
  			{
  				if(arr[k][l]=='#')
  					cnt++;
  			}
  		}
  		
  		if(cnt!=2)
  			return true;
  		return false;
  		
  		
  	}
  	
  	static void flag(boolean flag)
  	   {
  	       out.println(flag ? "YES" : "NO");
  	       out.flush();
  	   }
  	   
  	static ArrayList<Long> luckNums;
  	static void luckyNum(long x,long p10)
  	{
  		luckNums.add(x);
  		if(x>(long)1e10)
  			return;
  		luckyNum(x+4*p10, p10*10);
  		luckyNum(x+7*p10, p10*10);
  		
  	}
  	
  	 /*                     
  	    Map<Long,Long> map=new HashMap<>();
  	             for(int i=0;i<n;i++)
  	               {
  	                  if(!map.containsKey(a[i]))
  	                   map.put(a[i],1);
  	                 else
  	                   map.replace(a[i],map.get(a[i])+1);
  	               }
  	     
  	    Set<Map.Entry<Long,Long>> hmap=map.entrySet();
  	             for(Map.Entry<Long,Long> data : hmap)
  	               {
  	          
  	               }
  	       
  	   Iterator<Integer> it = set.iterator();
  	          while(it.hasNext()) 
  	           { 
  	            int x=it.next();
  	           }
  	   */
  
  
  	
  	
  	static void print(int a[])
  	  {
  	     int n=a.length;
  	     for(int i=0;i<n;i++)
  	       {
  	          out.print(a[i]+" ");
  	       }
  	     out.println();
  	     out.flush();
  	  }
  	static void print(long a[])
  	  {
  	     int n=a.length;
  	     for(int i=0;i<n;i++)
  	       {
  	          out.print(a[i]+" ");
  	       }
  	     out.println();
  	     out.flush();
  	  } 
  	static void print_int(ArrayList<Integer> al)
  	  {
  	     int si=al.size();
  	     for(int i=0;i<si;i++)
  	       {
  	          out.print(al.get(i)+" ");
  	       }
  	     out.println();
  	     out.flush();
  	  }
  	static void print_long(ArrayList<Long> al)
  	  {
  	     int si=al.size();
  	     for(int i=0;i<si;i++)
  	       {
  	          out.print(al.get(i)+" ");
  	       }
  	     out.println();
  	     out.flush();
  	  }
  	  
  	static void printYesNo(boolean condition)
  	{
  		if (condition) {
  			out.println("YES");
  		}
  		else {
  			out.println("NO");
  		}
  	}
  	
  	
  	static int LowerBound(int a[], int x) 
  	 { // x is the target value or key
  	  int l=-1,r=a.length;
  	  while(l+1<r) {
  	    int m=(l+r)>>>1;
  	    if(a[m]>=x) r=m;
  	    else l=m;
  	  }
  	  return r;
  	}
  	
  	
  	static int lowerIndex(int arr[], int n, int x)
      {
          int l = 0, h = n - 1;
          while (l <= h)
          {
              int mid = (l + h) / 2;
              if (arr[mid] >= x)
                  h = mid - 1;
              else
                  l = mid + 1;
          }
          return l;
      }
  	
  	
  	    // function to find last index <= y
      static int upperIndex(int arr[], int n, int y)
      {
          int l = 0, h = n - 1;
          while (l <= h)
          {
              int mid = (l + h) / 2;
              if (arr[mid] <= y)
                  l = mid + 1;
              else
                  h = mid - 1;
          }
          return h;
      }
      static int upperIndex(long arr[], int n, long y)
      {
      	int l = 0, h = n - 1;
      	while (l <= h)
      	{
      		int mid = (l + h) / 2;
      		if (arr[mid] <= y)
      			l = mid + 1;
      		else
      			h = mid - 1;
      	}
      	return h;
      }
       
  	
  	 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;
  	 }
  	 static int UpperBound(long a[], long 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;
  	 }
  	 
  	 
  	 
  	 static class DisjointUnionSets
  	 {
  	    int[] rank, parent;
  	    int n;
  	    // Constructor
  	    public DisjointUnionSets(int n)
  	    {
  	        rank = new int[n];
  	        parent = new int[n];
  	        this.n = n;
  	        makeSet();
  	    }
  	    // Creates n sets with single item in each
  	    void makeSet()
  	    {
  	        for (int i = 0; i < n; i++)
  	            parent[i] = i;
  	    }
  	    int find(int x)
  	    {
  	        if (parent[x] != x) {
  	            parent[x] = find(parent[x]);
  	        }
  	        return parent[x];
  	    }
  	    // Unites the set that includes x and the set
  	    // that includes x
  	    void union(int x, int y)
  	    {
  	        int xRoot = find(x), yRoot = find(y);
  	        if (xRoot == yRoot)
  	            return;
  	        if (rank[xRoot] < rank[yRoot])
  	            parent[xRoot] = yRoot;
  	        else if (rank[yRoot] < rank[xRoot])
  	         parent[yRoot] = xRoot;
  	        else // if ranks are the same
  	        {
  	         parent[yRoot] = xRoot;
  	            rank[xRoot] = rank[xRoot] + 1;
  	        }
  	    }
  	 }
  
  	 
  //	static class countClass{
  //		int cnt;
  //		public countClass() {
  //			this.cnt=0;
  //			// TODO Auto-generated constructor stub
  //		}
  //	}
  
  	 
  	 
  	static class Graph
  	  {
  	        int v;
  	        ArrayList<Integer> list[];
  	        Graph(int v)
  	        {
  	            this.v=v;
  	            list=new ArrayList[v+1];
  	            for(int i=1;i<=v;i++)
  	                list[i]=new ArrayList<Integer>();
  	        }
  	        void addEdge(int a, int b)
  	        {
  	            this.list[a].add(b);
  	        }
  	    }
  	
  //	static class GraphMap{
  //		Map<String,ArrayList<String>> graph;
  //		GraphMap() {
  //			// TODO Auto-generated constructor stub
  //			graph=new HashMap<String,ArrayList<String>>();
  //			
  //		}
  //		void addEdge(String a,String b)
  //		{
  //			if(graph.containsKey(a))
  //			this.graph.get(a).add(b);
  //			else {
  //				this.graph.put(a, new ArrayList<>());
  //				this.graph.get(a).add(b);
  //			}
  //		}
  //	}
  //	static void dfsMap(GraphMap g,HashSet<String> vis,String src,int ok)
  //	{
  //		vis.add(src);
  //		
  //		if(g.graph.get(src)!=null)
  //		{
  //			for(String each:g.graph.get(src))
  //			{
  //				if(!vis.contains(each))
  //				{
  //					dfsMap(g, vis, each, ok+1);
  //				}
  //			}
  //		}
  //		
  //		cnt=Math.max(cnt, ok);
  //	}
  	static double sum[];
  	static long cnt;
  	static void DFS(Graph g, boolean[] visited, int u)
  		{
  	        visited[u]=true;
  	        
  	        for(int i=0;i<g.list[u].size();i++)
  	        {
  	            int v=g.list[u].get(i);
  	            
  	            if(!visited[v])
  	            {
  	            	cnt=cnt*2;
  	            	DFS(g, visited, v);
  	            
  	            }
  	            
  	        }
  	       
  
  	  } 
  	
  	
  	  
  	 static class Pair implements Comparable<Pair>
  	    {
  	       int x,y;
  	       Pair(int x,int y)
  	        {
  	           this.x=x;
  	           this.y=y;
  	        }
  		@Override
  		public int compareTo(Pair o) {
  			// TODO Auto-generated method stub
  			return o.x-this.x;
  		}
  	       
  	       
  	       
  	    }
  	   
  	static long sum_array(int a[])
  	 {
  	    int n=a.length;
  	    long sum=0;
  	    for(int i=0;i<n;i++)
  	     sum+=a[i];
  	    return sum;
  	 }
  	static long sum_array(long a[])
  	 {
  	    int n=a.length;
  	    long sum=0;
  	    for(int i=0;i<n;i++)
  	     sum+=a[i];
  	    return sum;
  	 }
  
  	 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);
  		}
  	static void sort(long[] a) 
  	   {
  			ArrayList<Long> l=new ArrayList<>();
  			for (long i:a) l.add(i);
  			Collections.sort(l);
  			for (int i=0; i<a.length; i++) a[i]=l.get(i);
  		}
  
  	static void reverse_array(int a[])
  	 {
  	    int n=a.length;
  	    int i,t; 
  	    for (i = 0; i < n / 2; i++) { 
  	            t = a[i]; 
  	            a[i] = a[n - i - 1]; 
  	            a[n - i - 1] = t; 
  	        } 
  	 }
  	static void reverse_array(long a[])
  	 {
  	    int n=a.length;
  	    int i; long t; 
  	    for (i = 0; i < n / 2; i++) { 
  	            t = a[i]; 
  	            a[i] = a[n - i - 1]; 
  	            a[n - i - 1] = t; 
  	        } 
  	 }
  //	 static long modInverse(long a, long m)
  //		    {
  //		        long g = gcd(a, m);
  //		       
  //		          return   power(a, m - 2, m);
  //		        
  //		    }
  	static long power(long x, long y)
  	 {
  	   long res = 1;
  	   x = x % mod;
  	   if (x == 0)
  	     return 0;
  	   while (y > 0)
  	   {
  	    if ((y & 1) != 0)
  	    res = (res * x) % mod;
  	   
  	    y = y >> 1; // y = y/2
  	    x = (x * x) % mod;
  	   }
  	   return res;
  	 }
  	static long gcd(long a, long b) 
  	    { 
  			
  	        if (a == 0) 
  	            return b; 
  	         //cnt+=a/b;
  	        return gcd(b%a,a); 
  	    } 
  	static int gcd(int a, int b) 
  	    { 
  	        if (a == 0) 
  	            return b; 
  	          
  	        return gcd(b%a, a); 
  	    } 
  
  	   static class FastReader{
  	 
  	        byte[] buf = new byte[2048];
  	        int index, total;
  	        InputStream in;
  	 
  	        FastReader(InputStream is) {
  	            in = is;
  	        }
  	 
  	        int scan() throws IOException {
  	            if (index >= total) {
  	                index = 0;
  	                total = in.read(buf);
  	                if (total <= 0) {
  	                    return -1;
  	                }
  	            }
  	            return buf[index++];
  	        }
  	 
  	        String next() throws IOException {
  	            int c;
  	            for (c = scan(); c <= 32; c = scan());
  	            StringBuilder sb = new StringBuilder();
  	            for (; c > 32; c = scan()) {
  	                sb.append((char) c);
  	            }
  	            return sb.toString();
  	        }
  	 
  	        int nextInt() throws IOException {
  	            int c, val = 0;
  	            for (c = scan(); c <= 32; c = scan());
  	            boolean neg = c == '-';
  	            if (c == '-' || c == '+') {
  	                c = scan();
  	            }
  	            for (; c >= '0' && c <= '9'; c = scan()) {
  	                val = (val << 3) + (val << 1) + (c & 15);
  	            }
  	            return neg ? -val : val;
  	        }
  	 
  	        long nextLong() throws IOException {
  	            int c;
  	            long val = 0;
  	            for (c = scan(); c <= 32; c = scan());
  	            boolean neg = c == '-';
  	            if (c == '-' || c == '+') {
  	                c = scan();
  	            }
  	            for (; c >= '0' && c <= '9'; c = scan()) {
  	                val = (val << 3) + (val << 1) + (c & 15);
  	            }
  	            return neg ? -val : val;
  	        }
  	    }
  	   
  	    static class Reader 
  	    { 
  	        final private int BUFFER_SIZE = 1 << 16; 
  	        private DataInputStream din; 
  	        private byte[] buffer; 
  	        private int bufferPointer, bytesRead; 
  	  
  	        public Reader() 
  	        { 
  	            din = new DataInputStream(System.in); 
  	            buffer = new byte[BUFFER_SIZE]; 
  	            bufferPointer = bytesRead = 0; 
  	        } 
  	  
  	        public Reader(String file_name) throws IOException 
  	        { 
  	            din = new DataInputStream(new FileInputStream(file_name)); 
  	            buffer = new byte[BUFFER_SIZE]; 
  	            bufferPointer = bytesRead = 0; 
  	        } 
  	  
  	        public String readLine() throws IOException 
  	        { 
  	            byte[] buf = new byte[64]; // line length 
  	            int cnt = 0, c; 
  	            while ((c = read()) != -1) 
  	            { 
  	                if (c == '\n') 
  	                    break; 
  	                buf[cnt++] = (byte) c; 
  	            } 
  	            return new String(buf, 0, cnt); 
  	        } 
  	  
  	        public int nextInt() throws IOException 
  	        { 
  	            int ret = 0; 
  	            byte c = read(); 
  	            while (c <= ' ') 
  	                c = read(); 
  	            boolean neg = (c == '-'); 
  	            if (neg) 
  	                c = read(); 
  	            do
  	            { 
  	                ret = ret * 10 + c - '0'; 
  	            }  while ((c = read()) >= '0' && c <= '9'); 
  	  
  	            if (neg) 
  	                return -ret; 
  	            return ret; 
  	        } 
  	  
  	        public long nextLong() throws IOException 
  	        { 
  	            long ret = 0; 
  	            byte c = read(); 
  	            while (c <= ' ') 
  	                c = read(); 
  	            boolean neg = (c == '-'); 
  	            if (neg) 
  	                c = read(); 
  	            do { 
  	                ret = ret * 10 + c - '0'; 
  	            } 
  	            while ((c = read()) >= '0' && c <= '9'); 
  	            if (neg) 
  	                return -ret; 
  	            return ret; 
  	        } 
  	  
  	        public double nextDouble() throws IOException 
  	        { 
  	            double ret = 0, div = 1; 
  	            byte c = read(); 
  	            while (c <= ' ') 
  	                c = read(); 
  	            boolean neg = (c == '-'); 
  	            if (neg) 
  	                c = read(); 
  	  
  	            do { 
  	                ret = ret * 10 + c - '0'; 
  	            } 
  	            while ((c = read()) >= '0' && c <= '9'); 
  	  
  	            if (c == '.') 
  	            { 
  	                while ((c = read()) >= '0' && c <= '9') 
  	                { 
  	                    ret += (c - '0') / (div *= 10); 
  	                } 
  	            } 
  	  
  	            if (neg) 
  	                return -ret; 
  	            return ret; 
  	        } 
  	  
  	        private void fillBuffer() throws IOException 
  	        { 
  	            bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE); 
  	            if (bytesRead == -1) 
  	                buffer[0] = -1; 
  	        } 
  	  
  	        private byte read() throws IOException 
  	        { 
  	            if (bufferPointer == bytesRead) 
  	                fillBuffer(); 
  	            return buffer[bufferPointer++]; 
  	        } 
  	  
  	        public void close() throws IOException 
  	        { 
  	            if (din == null) 
  	                return; 
  	            din.close(); 
  	        } 
  	    }
  	  static  PrintWriter out=new PrintWriter(System.out);
  	  static int int_max=Integer.MAX_VALUE;
  	  static int int_min=Integer.MIN_VALUE;
  	  static long long_max=Long.MAX_VALUE;
  	  static long long_min=Long.MIN_VALUE;
  
  }
  
  
  
  
  