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


public class A {
  static final int INF = (int) 1e9 + 9;
  static final int MAXN = (int) 3e5 + 5;
  static final int MAXLOG = (int) (Math.log(MAXN) / Math.log(2) + 1e-10) + 1;
  static final int MOD = 1_000_000_007;

  static BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));
  static Reader in = new Reader();

  static int[][] cnt = new int[2][MAXN];

  public static void main(String[] args) throws IOException {
    Scanner in = new Scanner(System.in);
    // Scanner in = new Scanner(new File("breedflip.in"));
    // PrintWriter pw = new PrintWriter("breedflip.out");

    int t = in.nextInt();

    while(t-- > 0) {
      int n = in.nextInt();
      char[] a = in.next().toCharArray(),
        b = in.next().toCharArray();

      cnt[1][0] = cnt[0][0] = 0;

      for(int i = 0; i < n; ++i) {
        if(i == 0) {
          if(a[i] == '1') cnt[1][i] = 1;
          else cnt[0][i] = 1;
        }
        else if(a[i] == '1') {
          cnt[1][i] = cnt[1][i - 1] + 1;
          cnt[0][i] = cnt[0][i - 1];
        }
        else{
          cnt[0][i] = cnt[0][i - 1] + 1;
          cnt[1][i] = cnt[1][i - 1];
        } 
      }

      int one = 1;
      boolean possible = true;

      for(int i = n - 1; i >= 0 && possible; --i) {
        char c;
        if(one == 1) c = a[i];
        else {
          if(a[i] == '1') c = '0';
          else c = '1';
        }

        if(c == b[i]) continue;
        
        if(cnt[one][i] == cnt[one ^ 1][i]) {
          one ^= 1;
        } else possible = false;
      }

      System.out.println(possible ? "YES": "NO");
      
    }

    // pw.close();
    in.close();
  }

  static class Pair<U, V> implements Comparable<Pair<U, V>> {
    U first;
    V second;

    public Pair(U first, V second) {
      this.first = first;
      this.second = second;
    }

    @Override
    public boolean equals(Object obj) {
      if (obj == null)
        return false;
      Pair<U, V> o = (Pair<U, V>) obj;
      return this.first.equals(o.first) && this.second.equals(o.second);
    }

    @Override
    public int compareTo(Pair<U, V> p) {
      int firstC = ((Comparable) first).compareTo((Comparable) p.first);
      if (firstC == 0)
        return ((Comparable) second).compareTo((Comparable) p.second);
      return firstC;
    }
  }

  static class Reader {
    final private int BUFFER_SIZE = 1 << 16;
    private DataInputStream din;
    private byte[] buffer;
    private int bufferPointer, bytesRead;

    public Reader() {
      din = new DataInputStream(System.in);
      buffer = new byte[BUFFER_SIZE];
      bufferPointer = bytesRead = 0;
    }

    public Reader(String file_name) throws IOException {
      din = new DataInputStream(new FileInputStream(file_name));
      buffer = new byte[BUFFER_SIZE];
      bufferPointer = bytesRead = 0;
    }

    public String readLine() throws IOException {
      byte[] buf = new byte[64]; // line length
      int cnt = 0, c;
      while ((c = read()) != -1) {
        if (c == '\n')
          break;
        buf[cnt++] = (byte) c;
      }
      return new String(buf, 0, cnt);
    }

    public String next() throws IOException {
      byte[] buf = new byte[64]; // string length
      int cnt = 0, c;
      while ((c = read()) != -1) {
        if (c == ' ' || c == '\t' || c == '\n')
          break;
        buf[cnt++] = (byte) c;
      }
      return new String(buf, 0, cnt);
    }

    public int nextInt() throws IOException {
      int ret = 0;
      byte c = read();
      while (c <= ' ')
        c = read();
      boolean neg = (c == '-');
      if (neg)
        c = read();
      do {
        ret = ret * 10 + c - '0';
      } while ((c = read()) >= '0' && c <= '9');

      if (neg)
        return -ret;
      return ret;
    }

    public long nextLong() throws IOException {
      long ret = 0;
      byte c = read();
      while (c <= ' ')
        c = read();
      boolean neg = (c == '-');
      if (neg)
        c = read();
      do {
        ret = ret * 10 + c - '0';
      } while ((c = read()) >= '0' && c <= '9');
      if (neg)
        return -ret;
      return ret;
    }

    public double nextDouble() throws IOException {
      double ret = 0, div = 1;
      byte c = read();
      while (c <= ' ')
        c = read();
      boolean neg = (c == '-');
      if (neg)
        c = read();

      do {
        ret = ret * 10 + c - '0';
      } while ((c = read()) >= '0' && c <= '9');

      if (c == '.') {
        while ((c = read()) >= '0' && c <= '9') {
          ret += (c - '0') / (div *= 10);
        }
      }

      if (neg)
        return -ret;
      return ret;
    }

    private void fillBuffer() throws IOException {
      bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
      if (bytesRead == -1)
        buffer[0] = -1;
    }

    private byte read() throws IOException {
      if (bufferPointer == bytesRead)
        fillBuffer();
      return buffer[bufferPointer++];
    }

    public void close() throws IOException {
      if (din == null)
        return;
      din.close();
    }
  }
}