There is a binary string a of length n. In one operation, you can select any prefix of a with an equal number of 0 and 1 symbols. Then all symbols in the prefix are inverted: each 0 becomes 1 and each 1 becomes 0.

For example, suppose a=0111010000. 

  * In the first operation, we can select the prefix of length 8 since it has four 0's and four 1's: [01110100]00→ [10001011]00. 
  * In the second operation, we can select the prefix of length 2 since it has one 0 and one 1: [10]00101100→ [01]00101100. 
  * It is illegal to select the prefix of length 4 for the third operation, because it has three 0's and one 1. 



Can you transform the string a into the string b using some finite number of operations (possibly, none)?

Input

The first line contains a single integer t (1≤ t≤ 10^4) — the number of test cases.

The first line of each test case contains a single integer n (1≤ n≤ 3⋅ 10^5) — the length of the strings a and b.

The following two lines contain strings a and b of length n, consisting of symbols 0 and 1.

The sum of n across all test cases does not exceed 3⋅ 10^5.

Output

For each test case, output "YES" if it is possible to transform a into b, or "NO" if it is impossible. You can print each letter in any case (upper or lower).

Example

Input


5
10
0111010000
0100101100
4
0000
0000
3
001
000
12
010101010101
100110011010
6
000111
110100


Output


YES
YES
NO
YES
NO

Note

The first test case is shown in the statement.

In the second test case, we transform a into b by using zero operations.

In the third test case, there is no legal operation, so it is impossible to transform a into b.

In the fourth test case, here is one such transformation: 

  * Select the length 2 prefix to get 100101010101. 
  * Select the length 12 prefix to get 011010101010. 
  * Select the length 8 prefix to get 100101011010. 
  * Select the length 4 prefix to get 011001011010. 
  * Select the length 6 prefix to get 100110011010. 



In the fifth test case, the only legal operation is to transform a into 111000. From there, the only legal operation is to return to the string we started with, so we cannot transform a into b.
import java.io.*; 
import java.util.*; 
  
public class ClientCall2 { 
	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;
	        }
	    }  

	public static void main(String args[]) {
		FastReader sc = new FastReader();
    	int t = sc.nextInt();
    	
    	for(int c=0;c<t;c++) {
    	int n = sc.nextInt();
    	String a1 = sc.nextLine();
    	String b1 = sc.nextLine();
    	
    	int no0a= 0;
    	int no0b= 0;
    	int a[]= new int[n];
    	int b[]= new int[n];
    	
    	for(int d=0;d<n;d++) {
    		if(a1.charAt(d)=='0') {
    			no0a++;
    		}
    		if(b1.charAt(d)=='0') {
    			no0b++;
    		}
    		
    		a[d]=no0a;
    		b[d]=no0b;
    		
    	}
    	
    	int z=0; boolean y=true;
    	for(int d=n-1;d>=0;d--) {
    	if(z%2==0 && a1.charAt(d)!=b1.charAt(d)) {
    		z++;
    		if(a[d]==b[d] && 2*a[d]==d+1) {
    			
    		}
    		else {
    			y=false;
    			break;
    		}
    		
    	}
    	
    	if(z%2==1 && a1.charAt(d)==b1.charAt(d)) {
    		z++;
    		if(a[d]==b[d] && 2*a[d]==d+1) {
    			
    		}
    		else {
    			y=false;
    			break;
    		}
    		
    	}
    	
    	}
    	
    	
    	
    	
    	if(y) {
    		System.out.println("YES");
    	}
    	else {
    		System.out.println("NO");
    	}
    	
    	
    	
    	
    	}
    	
    	  
     
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	}
   
} 


