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.util.*;
import java.io.*;
import java.lang.*;

public class cf712 {
    
    
        public static void main(String[] args) throws Exception{
            InputStreamReader ip=new InputStreamReader(System.in);
            BufferedReader br = new BufferedReader(ip);
            // Scanner scn=new Scanner(System.in);
            int t = Integer.parseInt(br.readLine());
            // fill();
    
           while(t-->0){
            int n =Integer.parseInt(br.readLine());
            // String[] strs=(br.readLine()).trim().split(" ");
            String stra=(br.readLine()).trim();
            String strb=(br.readLine()).trim();

            int[] ct0=new int[n];
            int[] ct1=new int[n];
            char []arr1=stra.toCharArray();
            char []arr2=strb.toCharArray();

            int i=0;
            for(int ch:arr1){
                if(ch=='0'){
                    ct0[i]++;
                }else{
                    ct1[i]++;
                }
                if(i>0){ct0[i]+=ct0[i-1];  ct1[i]+=ct1[i-1];  }
                i++;
            }

            int flip=0;

            int e1=n-1;//,e2=n-1;
            boolean flag=true;

            while(e1>=0){

                if(flip%2==1){
                    if(arr1[e1]=='0'){ arr1[e1]='1'; }
                    else{ arr1[e1]='0';  }
                }

                if(arr1[e1]!=arr2[e1]){
                    if(ct0[e1]==ct1[e1]){flip++;}
                    else{flag=false; break;}
                }
                e1--;
            }


            if(!flag){
                System.out.println("NO");  //"a1"+
            }else{
                System.out.println("YES");  
            }
           }
        }
    }    



//     public static void main(String[] args) throws Exception{
//         InputStreamReader ip=new InputStreamReader(System.in);
//         BufferedReader br = new BufferedReader(ip);
//         // Scanner scn=new Scanner(System.in);
//         int t = Integer.parseInt(br.readLine());
//         // fill();

//        while(t-->0){
//         // int n =Integer.parseInt(br.readLine());
//         // String[] strs=(br.readLine()).trim().split(" ");
//         String str=(br.readLine()).trim();
//         int ct=0;
//         for(char ch:str.toCharArray()){
//             if(ch=='a'){ct++;}
//         }

//         if(ct==str.length()){
//             System.out.println("NO");
//         }else{
//             System.out.println("YES");
//             int n=str.length();
//             // StringBuilder sb=new StringBuilder();
//             // sb.append(str);

//             int lo=0,hi=0;
//             String last=str+'a';
//             boolean isp=true;
//             n++;
//             if(n%2==0){
//                 lo=(n-1)/2;  hi=n/2;
//             }else{
//                 lo=n/2; hi=n/2;
//             }

//             while(lo>=0 && hi<n){
//                 if(last.charAt(lo)!=last.charAt(hi)){
//                     isp=false;  break;
//                 }
//                 lo--; hi++;
//             }

            
//             if(!isp){
//                 System.out.println(last);    //"l="+
//             }else{
//                 String first='a'+str;
//                 System.out.println(first);   //"f="+
//             }

            

//             // if(n%2==0){
//             //     lo=(n-1)/2;  hi=n/2;
//             // }else{
//             //     lo=n/2; hi=n/2;
//             // }

//             // while(lo>=0 && hi<n){
//             //     if(first.charAt(lo)!=first.charAt(hi)){
//             //         isp=false;  break;
//             //     }
//             //     lo--; hi++;
//             // }

//             // System.out.println(first);


//             // String ans="";
//             // while(lo>=0 && hi<n){
//             //     if(last.charAt(lo)!='a'){
//             //         ans=str.substring(0, hi)+'a'+str.substring(hi);  break;
//             //     }else if(str.charAt(hi)!='a'){
//             //         ans=str.substring(0, lo)+'a'+str.substring(lo);  break;
//             //     }
//             //     lo--; hi++;
//             // }

//             // System.out.println("a="+ans);
//         }
//        }
//     }

// }
