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.util.*;
import java.io.*;

public class A2oj2 {

    static FastReader sc;
    static PrintWriter out;
    static int mod = 1000000007;

    public static void main(String[] args) throws IOException {
        if (System.getProperty("ONLINE_JUDGE") == null) {
            File f1 = new File("input.txt");
            File f2 = new File("output.txt");
            Reader r = new FileReader(f1);
            sc = new FastReader(r);
            out = new PrintWriter(f2);
            double prev = System.currentTimeMillis();
            solve();
            out.println("\n\nExecuted in : " + ((System.currentTimeMillis() - prev) / 1e3) + " sec");
        } else {
            sc = new FastReader(new InputStreamReader(System.in));
            out = new PrintWriter(System.out);
            solve();
        }
        out.flush();
        out.close();
    }

    static void solve() {
        int t = sc.nextInt();
        StringBuilder ans = new StringBuilder("");
        while (t-- > 0) {
            int n = sc.nextInt(), high = -1;
            char[] s1 = sc.nextLine().toCharArray(), s2 = sc.nextLine().toCharArray();
            boolean z = true;
            for (int i = 0; i < n; i++) {
                if (s1[i] != s2[i]) {
                    z = false;
                    high = i;
                }
            }
            if (z) {
                ans.append("YES\n");
                continue;
            }
            int[] pre0 = new int[n], pre1 = new int[n];
            if (s1[0] == '0') {
                pre0[0] = 1;
            } else {
                pre1[0] = 1;
            }
            for (int i = 1; i < n; i++) {
                if (s1[i] == '0') {
                    pre0[i] = pre0[i - 1] + 1;
                    pre1[i] = pre1[i - 1];
                } else {
                    pre1[i] = pre1[i - 1] + 1;
                    pre0[i] = pre0[i - 1];
                }
            }
            boolean ch = false, x = true;
            int l = 0, r = 0;
            if (s1[0] == s2[0]) {
                ch = true;
            }
            for (int i = 1; i < n; i++) {
                if (i > high)
                    break;
                if (!ch) {
                    if (s1[i] != s2[i]) {
                        r++;
                    } else {
                        if (l == 0) {
                            if (pre1[r] != pre0[r]) {
                                x = false;
                                break;
                            }
                        } else {
                            if (pre1[r] - pre1[l - 1] != pre0[r] - pre0[l - 1]) {
                                x = false;
                                break;
                            }
                        }
                        ch = true;
                        l = r = i;
                    }
                } else {
                    if (s1[i] == s2[i]) {
                        r++;
                    } else {
                        if (l == 0) {
                            if (pre1[r] != pre0[r]) {
                                x = false;
                                break;
                            }
                        } else {
                            if (pre1[r] - pre1[l - 1] != pre0[r] - pre0[l - 1]) {
                                x = false;
                                break;
                            }
                        }
                        ch = false;
                        l = r = i;
                    }
                }
            }
            if (l == 0) {
                if (pre1[r] != pre0[r]) {
                    x = false;
                }
            } else {
                if (pre1[r] - pre1[l - 1] != pre0[r] - pre0[l - 1]) {
                    x = false;
                }
            }
            if (x) {
                ans.append("YES\n");
            } else {
                ans.append("NO\n");
            }

        }
        out.println(ans);
    }

    static long modInverse(long a) {
        long g = gcd(a, mod);
        if (g != 1)
            return -1;
        else {
            return power(a, mod - 2L);
        }
    }

    static long power(long x, long y) {
        long res = 1;
        x = x % mod;
        if (x == 0)
            return 0;
        while (y > 0) {
            if ((y & 1) != 0)
                res = (res * x) % mod;
            y = y >> 1;
            x = (x * x) % mod;
        }
        return res;
    }

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

    static boolean isPerfectSquare(double x) {
        if (x >= 0) {
            double sr = Math.sqrt(x);
            return ((sr * sr) == x);
        }
        return false;
    }

    public static int digitsCount(long x) {
        return (int) Math.floor(Math.log10(x)) + 1;
    }

    public static boolean isPowerTwo(long n) {
        return (n & n - 1) == 0;
    }

    static void sieve(boolean[] prime, int n) { // Sieve Of Eratosthenes
        for (int i = 1; i <= n; i++) {
            prime[i] = true;
        }
        for (int i = 2; i * i <= n; i++) {
            if (prime[i]) {
                for (int j = 2; i * j <= n; j++) {
                    prime[i * j] = false;
                }
            }
        }
    }

    static void fillGraph(ArrayList<ArrayList<Integer>> adj) {
        int n = sc.nextInt(), m = sc.nextInt();
        for (int i = 0; i < n + 1; i++) {
            adj.add(new ArrayList<Integer>());
        }
        for (int i = 1; i <= m; i++) {
            int x = sc.nextInt(), y = sc.nextInt();
            adj.get(x).add(y);
            adj.get(y).add(x);
        }
    }

    static void dfs(ArrayList<ArrayList<Integer>> adj, boolean[] visited, int v) {
        visited[v] = true;
        out.print(v + " ");
        for (Integer i : adj.get(v)) {
            if (!visited[i])
                dfs(adj, visited, i);
        }
    }

    static void bfs(ArrayList<ArrayList<Integer>> adj, int V, int s) {
        boolean[] visited = new boolean[V];
        Queue<Integer> q = new LinkedList<>();
        visited[s] = true;
        q.add(s);
        while (!q.isEmpty()) {
            s = q.poll();
            out.print(s + " ");
            for (Integer i : adj.get(s)) {
                if (!visited[i]) {
                    visited[i] = true;
                    q.add(i);
                }
            }
        }
    }

    int fib(int n) { // n-th Fibonacci Number
        int a = 0, b = 1, c, i;
        if (n == 0)
            return a;
        for (i = 2; i <= n; i++) {
            c = a + b;
            a = b;
            b = c;
        }
        return b;
    }

    static long nCr(int n, int r) { // Combinations
        if (n < r)
            return 0;
        if (r > n - r) { // because nCr(n, r) == nCr(n, n - r)
            r = n - r;
        }
        long ans = 1L;
        for (int i = 0; i < r; i++) {
            ans *= (n - i);
            ans /= (i + 1);
        }
        return ans;
    }

    static long catalan(int n) { // n-th Catalan Number
        long c = nCr(2 * n, n);
        return c / (n + 1);
    }

    static class Pair implements Comparable<Pair> { // Pair Class
        long x;
        long y;

        public Pair(long x, long y) {
            this.x = x;
            this.y = y;
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) {
                return true;
            }
            if (!(o instanceof Pair)) {
                return false;
            }

            Pair pair = (Pair) o;

            if (x != pair.x) {
                return false;
            }
            if (y != pair.y) {
                return false;
            }

            return true;
        }

        @Override
        public int hashCode() {
            long result = x;
            result = 31 * result + y;
            return (int) result;
        }

        @Override
        public int compareTo(Pair o) {
            return (int) (this.x - o.x);
        }
    }

    static class Trip { // Triplet Class
        long x;
        long y;
        long z;

        Trip(long x, long y, long z) {
            this.x = x;
            this.y = y;
            this.z = z;
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) {
                return true;
            }
            if (!(o instanceof Trip)) {
                return false;
            }

            Trip trip = (Trip) o;

            if (x != trip.x) {
                return false;
            }
            if (y != trip.y) {
                return false;
            }
            if (z != trip.z) {
                return false;
            }
            return true;
        }

        @Override
        public int hashCode() {
            long result = 62 * x + 31 * y + z;
            return (int) result;
        }
    }

    static class FastReader {
        BufferedReader br;
        StringTokenizer st;

        public FastReader(Reader r) {
            br = new BufferedReader(r);
        }

        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;
        }
    }
}