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.
#include <bits/stdc++.h>
using namespace std;
#define en '\n'
#define mems(arr,VAL)     memset(arr,VAL,sizeof(arr))
#define ll long long
#define vll vector<ll>
#define fo(i, a, b) for(ll i = a; i < b; i++)
#define fb(i, a, b) for(ll i = a; i > b; i--)
#define fv(it,v) for(auto it=v.begin();it<v.end();it++)
#define fi first
#define se second
#define pb push_back
#define in insert
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define sz(a) int(a.size())
#define pll pair<ll, ll>
#define plll pair<ll, pll>
#define vpll vector<pll>
#define vplll vector<plll>
#define lbnd lower_bound
#define ubnd upper_bound
#define mp map<ll,ll>
#define gcd(a,b)    __gcd((a),(b))
#define lcm(a,b)    ((a)*(b)) / gcd((a),(b))
#define RemoveDuplicates(a) a.resize(unique(all(a))-a.begin())
#define tle int(1e9) + 7
template <typename Arg1>
void pn(Arg1&& arg1)
{ cout << arg1 << "\n";}
template <typename Arg1, typename... Args>
void pn(Arg1&& arg1, Args&&... args)
{ cout << arg1 << "\n"; pn(args...); }

template <typename Arg1>
void ps(Arg1&& arg1)
{ cout << arg1 << " ";}
template <typename Arg1, typename... Args>
void ps(Arg1&& arg1, Args&&... args)
{ cout << arg1 << " "; ps(args...); }

template <typename Arg1>
void pvs(Arg1&& arg1, ll n)
{ for (ll i = 0; i < n; i++)ps(arg1[i]); }
template <typename Arg1>
void pvn(Arg1&& arg1, ll n)
{ for (ll i = 0; i < n; i++)pn(arg1[i]); }
//-----------------------------------------------------------------------------------------------------------------------------
// code


void solve() {
	ll n, y, z, p, x, k, l, sum = 0, flag = 0, t, ans = 0;
	string s, s1 = "", s2;
	cin >> n >> s >> s1;
	z = 0;
	ll o = 0;
	vpll a(n);
	fo(i, 0, n) {
		if (s[i] == '0')z++;
		else o++;
		a[i] = {z, o};
	}
	fb(i, n - 1, -1) {
		if ((i % 2 == 0) && ( (flag == 0 && s[i] != s1[i]) || (flag == 1 && s[i] == s1[i]))) {
			pn("NO");
			return;
		}
		else {
			if ((flag == 0 && s[i] == s1[i]) || (flag == 1 && s[i] != s1[i]))continue;
			else {
				if (flag == 0) z = a[i].fi, o = a[i].se;
				else o = a[i].fi, z = a[i].se;
				if (z != o) {
					pn("NO");
					return;
				}
				else {
					flag ^= 1;
				}
			}
		}
	}
	pn("YES");
}

int main() {
	ios_base::sync_with_stdio(false);
	cin.tie(NULL);
#ifndef ONLINE_JUDGE
	freopen("input.txt", "r", stdin);
	freopen("output.txt", "w", stdout);
#endif
#ifdef NCR
	init();
#endif
	int test = 1;
	cin >> test;
	while (test--) {
		// cout<<"Case #"<<i++<<":"<<en;
		solve();
	}
	return 0;
}