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.
/*

I FOLLOW THE WAY OF THE RIGHT HONOURABLE JIM KWIK,
GOD BLESS YOU SIR

1.  I AM A 'NEWBIE' IN RATING
2.  I WILL FAIL MANY TIMES, BUT I WILL NOT FAIL TO LEARN FROM FAILURE
3.  I WILL NEVER SURRENDER MY GOAL, NO MATTER HOW MUCH I FAIL
4.  I WILL PROVE MY SKILLS WHEN THE TIME COMES
5.  I WILL ALWAYS KEEP TRYING

*/










import java.util.*;
import java.io.*;
public class A  {

















    static boolean tests = true;
    static int get(int x, int pressed){
        if (pressed % 2 == 0) return x;
        return x == 0 ? 1 : 0;
    }
    static void solve(){
        int n = in.nextInt();
       char[] s = in.next().toCharArray();
       char[] t = in.next().toCharArray();
       int[] sum = new int[n+1];
       int p = 0;
       boolean equals = true;
       for (int i = 0; i < n; ++i){
           sum[i] = (s[i] == '1' ? 1 : -1)+p;
           p = sum[i];
           if (t[i] != s[i]) equals = false;
       }
       if (equals){
           out.println("YES");
           return;
       }
       int cnt = 0;
       for (int i = n-1; i >= 0; --i){
           if (get(s[i]-'0', cnt) != t[i]-'0'){
               if (sum[i] == 0) ++cnt;
               else{
                   out.println("NO");
                   return;
               }
           }
       }
       out.println("YES");
    }




























    static Reader in;
    static PrintWriter out;
    static int int_max = (int)1e9, mod = 998244353;
    public static void main(String[] args){
        in = new Reader();
        out = new PrintWriter(System.out);
        int t = tests ? in.nextInt() : 1;
        while (t-- > 0) solve();
        out.close();
    }
    static class Reader{
        // Reader credited to SecondThread
        BufferedReader b;
        StringTokenizer s;
        Reader(){
            this.b = new BufferedReader(new InputStreamReader(System.in));
            this.s = new StringTokenizer("");
        }
        String next(){
            while (!s.hasMoreTokens())
                try{s = new StringTokenizer(b.readLine());
                }catch(IOException ignored){}
            return s.nextToken();
        }
        int nextInt(){return Integer.parseInt(next());}
        long nextLong(){return Long.parseLong(next());}
        double nextDouble(){return Double.parseDouble(next());}
        int[] ai(int n){
            int[] a = new int[n];
            for (int i = 0; i < n; ++i)
                a[i] = nextInt();
            return a;
        }
        long[] al(int n){
            long[] a = new long[n];
            for (int i = 0; i < n; ++i)
                a[i] = nextLong();
            return a;
        }
    }
}