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 static java.lang.Integer.parseInt;
import static java.lang.Long.parseLong;
import static java.lang.Math.abs;
import static java.lang.Math.max;
import static java.lang.System.arraycopy;
import static java.lang.System.exit;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class CodeForces2 {

	static final int MOD = 998244353;

	static int add(int a, int b) {
		int res = a + b;
		return res >= MOD ? res - MOD : res;
	}

	static int sub(int a, int b) {
		int res = a - b;
		return res < 0 ? res + MOD : res;
	}

	static int mul(int a, int b) {
		int res = (int) ((long) a * b % MOD);
		return res < 0 ? res + MOD : res;
	}

	static int pow(int a, int e) {
		if (e == 0) {
			return 1;
		}
		int r = a;
		for (int i = 30 - Integer.numberOfLeadingZeros(e); i >= 0; i--) {
			r = mul(r, r);
			if ((e & (1 << i)) != 0) {
				r = mul(r, a);
			}
		}
		return r;
	}

	static int inv(int a) {
		return pow(a, MOD - 2);
	}

	static final int HALF = (MOD + 1) / 2;

	static int dbl(int a) {
		return add(a, a);
	}

	static int half(int a) {
		return mul(a, HALF);
	}

    static int gcd(int a,int b){
         if(b==0) {
             return a;
         }
         return gcd(b,a%b);
    }

	static int scanInt() throws IOException {
		return parseInt(scanString());
	}

	static long scanLong() throws IOException {
		return parseLong(scanString());
	}

	static String scanString() throws IOException {
		while (tok == null || !tok.hasMoreTokens()) {
			tok = new StringTokenizer(in.readLine());
		}
		return tok.nextToken();
	}

	
	static BufferedReader in;
	static PrintWriter out;
	static StringTokenizer tok;
	public static void main(String[] args) {
		try {
			in = new BufferedReader(new InputStreamReader(System.in));
			out = new PrintWriter(System.out);
			solve();
			in.close();
			out.close();
		} catch (Throwable e) {
			e.printStackTrace();
			exit(1);
		}
	}

    	static void solve() throws Exception {
		int t = scanInt();
		while(t-->0){
			int n = scanInt();
			String a=scanString();
			String b= scanString();

			int zero[]=new int[n];
			int one[]=new int[n];
			int flipIndex=n-1;
			int noOfFlip=0;

			for(int i=0;i<n;i++){

				if(a.charAt(i)=='0'){
					
					if(i==0){
						zero[i]=1;
					}

					if(i!=0){
						zero[i]=zero[i-1]+1;
						one[i]=one[i-1];
					}
				}
				if(a.charAt(i)=='1'){
					
					if(i==0){
						one[i]=1;
					}

					if(i!=0){
						zero[i]=zero[i-1];
						one[i]=one[i-1]+1;
					}
				}
			}

			boolean val=true;
			for(int i=n-1;i>=0;i--){

				if(noOfFlip%2==0){
					if(a.charAt(i)!=b.charAt(i)){

						if(zero[i]==one[i]){

						flipIndex=i;
						noOfFlip++;
						i++;
						}
						else{
							System.out.println("NO");
							val=false;
							break;
						}

					}
				}
				else{
					char aa=a.charAt(i)=='0'?'1':'0';

					if(aa!=b.charAt(i)){
						if(zero[i]==one[i]){
						flipIndex=i;
						noOfFlip++;
						i++;
						}
						else{
							System.out.println("NO");
							val=false;
							break;
						}
					}


				}

			}

			if(val){
				System.out.println("YES");
			}

		}

		// char s[] = scanString().toCharArray();
		// out.println(n);
		// out.print(s);


	}
}


