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.*;
import java.util.Arrays;
import java.util.List;
import java.util.StringTokenizer;

@SuppressWarnings("DuplicatedCode")
public class Main {
    static PrintWriter pw;
    static Scanner sc;

    public static void main(String[] args) throws Exception {
        sc = new Scanner(System.in);
        pw = new PrintWriter(System.out);
        //long startTime = System.currentTimeMillis();
        int t = sc.nextInt();
        while (t-- > 0) {
            solve();
        }
        pw.flush();
        //System.out.println(System.currentTimeMillis() - startTime);
    }

    private static void solve() throws IOException {
        int n = sc.nextInt();

        boolean[] a = new boolean[n];
        boolean[] b = new boolean[n];
        boolean[] aCan = new boolean[n];

        char[] aChars = sc.nextLine().toCharArray();
        char[] bChars = sc.nextLine().toCharArray();

        int aCount = 0;
        for (int i = 0; i < n; ++i) {
            boolean aVal = aChars[i] == '1';
            a[i] = aVal;
            b[i] = bChars[i] == '1';

            if (aVal) {
                ++aCount;
            } else {
                --aCount;
            }
            aCan[i] = aCount == 0;
        }

        boolean mirrored = false;
        for (int i = n - 1; i >= 0; --i) {
            boolean isOk = false;
            if (!mirrored) {
                isOk = (a[i] == b[i]);
            } else {
                isOk = (a[i] != b[i]);
            }
            if (!isOk) {
                if (aCan[i]) {
                    mirrored = !mirrored;
                } else {
                    pw.println("NO");
                    return;
                }
            }
        }
        pw.println("YES");
    }

    static class Shuffle {
        static void run(int[] in) {
            for (int i = 0; i < in.length; i++) {
                int idx = (int) (Math.random() * in.length);
                int tmp = in[i];
                in[i] = in[idx];
                in[idx] = tmp;
            }
        }

        static void run(long[] in) {
            for (int i = 0; i < in.length; i++) {
                int idx = (int) (Math.random() * in.length);
                long tmp = in[i];
                in[i] = in[idx];
                in[idx] = tmp;
            }
        }

        static <T> void run(List<T> in) {
            for (int i = 0; i < in.size(); i++) {
                int idx = (int) (Math.random() * in.size());
                T tmp = in.get(i);
                in.set(i, in.get(idx));
                in.set(idx, tmp);
            }
        }
    }

    static class Scanner {
        StringTokenizer st;
        BufferedReader br;

        Scanner(InputStream system) {
            br = new BufferedReader(new InputStreamReader(system));
        }

        Scanner(String file) throws Exception {
            br = new BufferedReader(new FileReader(file));
        }

        String next() throws IOException {
            while (st == null || !st.hasMoreTokens())
                st = new StringTokenizer(br.readLine());
            return st.nextToken();
        }

        int[] intArr(int n) throws IOException {
            int[] in = new int[n];
            for (int i = 0; i < n; i++) in[i] = nextInt();
            return in;
        }

        long[] longArr(int n) throws IOException {
            long[] in = new long[n];
            for (int i = 0; i < n; i++) in[i] = nextLong();
            return in;
        }

        int[] intSortedArr(int n) throws IOException {
            int[] in = new int[n];
            for (int i = 0; i < n; i++) in[i] = nextInt();
            Shuffle.run(in);
            Arrays.sort(in);
            return in;
        }

        long[] longSortedArr(int n) throws IOException {
            long[] in = new long[n];
            for (int i = 0; i < n; i++) in[i] = nextLong();
            Shuffle.run(in);
            Arrays.sort(in);
            return in;
        }

        Integer[] IntegerArr(int n) throws IOException {
            Integer[] in = new Integer[n];
            for (int i = 0; i < n; i++) in[i] = nextInt();
            return in;
        }

        Long[] LongArr(int n) throws IOException {
            Long[] in = new Long[n];
            for (int i = 0; i < n; i++) in[i] = nextLong();
            return in;
        }

        String nextLine() throws IOException {
            return br.readLine();
        }

        int nextInt() throws IOException {
            return Integer.parseInt(next());
        }

        double nextDouble() throws IOException {
            return Double.parseDouble(next());
        }

        char nextChar() throws IOException {
            return next().charAt(0);
        }

        long nextLong() throws IOException {
            return Long.parseLong(next());
        }

        boolean ready() throws IOException {
            return br.ready();
        }
    }
}
