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.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Set;
import java.util.Stack;
import java.util.StringTokenizer;

public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		FastReader s = new FastReader();
		int tc = s.nextInt();
		while(tc-- > 0) {
			int n = s.nextInt();
			char[] a = s.next().toCharArray();
			char[] b = s.next().toCharArray();
			zone[] prefix = new zone[a.length];
			if(a.length != b.length) {
				System.out.println("NO");
				continue;
			}
			//System.out.println("RE");
			for(int i = 0;i < a.length;i++) {
				prefix[i] = new zone();
				if(i != 0) {
					if(a[i] == '0') {
						prefix[i].zero = prefix[i - 1].zero + 1;
						prefix[i].one = prefix[i - 1].one;
					}
					else {
						prefix[i].one = prefix[i - 1].one + 1;
						prefix[i].zero = prefix[i - 1].zero;
					}
				}
				else {
					if(a[i] == '0') {
						prefix[i].zero = 1;
						prefix[i].one = 0;
					}
					else {
						prefix[i].one = 1;
						prefix[i].zero = 0;
					}
				}
			}
//			for(int i = 0;i < a.length;i++) {
//				System.out.println(prefix[i].one + " " + prefix[i].zero);
//			}
			boolean rev = false;
			boolean possible = true;
			for(int i = a.length - 1;i >= 0;i--) {
				if(a[i] == b[i] && !rev) continue;
				else if(rev && a[i] != b[i]) continue;
				if(prefix[i].one != prefix[i].zero) {
					possible = false;
					break;
				}
				rev = !rev;
				
			}
			if(!possible) System.out.println("NO");
			else System.out.println("YES");
 		}
	}

	public static long fact(int n , long mod) {
		long mul = 1;
		for(int i = 2;i <= n;i++) mul = ((mul%mod) * (i%mod))%mod;
		return mul;
	}

	

	public static int nextGreater(int val , boolean[] taken) {
		int n = taken.length/2;
		for(int i = val + 1;i <= 2*n;i++) {
			if(!taken[i]) {
				taken[i] = true;
				return i;
			}
		}
		return -1;
	}
}

class zone {
	int zero;
	int one;
}
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; 
	} 
} 
