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.

//package codeForces;

import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.io.*;
import java.math.*;
import java.text.*;

public class B712 {

  static InputReader in = new InputReader(System.in);
  static OutputWriter out = new OutputWriter(System.out);

  public static void main(String[] args)
      throws NumberFormatException, IOException {
    // TODO Auto-generated method stub
    BufferedReader br = new BufferedReader(
        new InputStreamReader(System.in));
    int t = i();
    PrintWriter out = new PrintWriter(System.out);
    while (t > 0) {
      
      int n=i();
      String a=s();
      String b=s();
 
      boolean sm=true;
      int c0[]=new int[n];
      int c1[]=new int[n];
      if(a.charAt(0)=='0') {
        c0[0]=1;
      }
      else {
        c1[0]=1;
      }
      for(int i=1;i<n;i++) {
        if(a.charAt(i)=='0') {
          c0[i]=c0[i-1]+1;
          c1[i]=c1[i-1];
        }
        else {
          c0[i]=c0[i-1];
          c1[i]=c1[i-1]+1;
        }
      }
      
      int p=0;
      for(int i=n-1;i>=0;i--) {
        if(sm) {
          if(a.charAt(i)!=b.charAt(i)) {
            if(c0[i]!=c1[i]) {
              p=1;
              break;
            }
            sm=!sm;
          }
        }
        else {
          if(a.charAt(i)==b.charAt(i)) {
            if(c0[i]!=c1[i]) {
              p=1;
              break;
            }
            sm=!sm;
          }
        }
      }
      if(p==0) {
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }

      out.println();

      t--;

    }
    out.close();

    //      long l=l();
    //      String s=s();     //    ONLY BEFORE SPACE IN STRING , ELSE USE BUFFER-READER

  }

  public static long pow(long a, long b) {
    long m = 1000000007;
    long result = 1;
    while (b > 0) {
      if (b % 2 != 0) {
        result = (result * a) % m;
        b--;
      }
      a = (a * a) % m;
      b /= 2;
    }
    return result % m;
  }

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

  public static long lcm(long a, long b) {
    return a * (b / gcd(a, b));
  }

  public static long l() {
    String s = in.String();
    return Long.parseLong(s);
  }

  public static void pln(String value) {
    System.out.println(value);
  }

  public static int i() {
    return in.Int();
  }

  public static String s() {
    return in.String();
  }

}

class pair {
  int x, y;

  pair(int x, int y) {
    this.x = x;
    this.y = y;
  }
}

class CompareValue {

  static void compare(pair arr[], int n) {
    Arrays.sort(arr, new Comparator<pair>() {
      public int compare(pair p1, pair p2) {
        return p1.y - p2.y;
      }
    });
  }
}

class CompareKey {
  static void compare(pair arr[], int n) {
    Arrays.sort(arr, new Comparator<pair>() {
      public int compare(pair p1, pair p2) {
        return p2.x - p1.x;
      }
    });
  }
}

class InputReader {
  private InputStream stream;
  private byte[] buf = new byte[1024];
  private int curChar;
  private int numChars;
  private SpaceCharFilter filter;

  public InputReader(InputStream stream) {
    this.stream = stream;
  }

  public int read() {
    if (numChars == -1)
      throw new InputMismatchException();
    if (curChar >= numChars) {
      curChar = 0;
      try {
        numChars = stream.read(buf);
      } catch (IOException e) {
        throw new InputMismatchException();
      }
      if (numChars <= 0)
        return -1;
    }
    return buf[curChar++];
  }

  public int Int() {
    int c = read();
    while (isSpaceChar(c))
      c = read();
    int sgn = 1;
    if (c == '-') {
      sgn = -1;
      c = read();
    }
    int res = 0;
    do {
      if (c < '0' || c > '9')
        throw new InputMismatchException();
      res *= 10;
      res += c - '0';
      c = read();
    } while (!isSpaceChar(c));
    return res * sgn;
  }

  public String String() {
    int c = read();
    while (isSpaceChar(c))
      c = read();
    StringBuilder res = new StringBuilder();
    do {
      res.appendCodePoint(c);
      c = read();
    } while (!isSpaceChar(c));
    return res.toString();
  }

  public boolean isSpaceChar(int c) {
    if (filter != null)
      return filter.isSpaceChar(c);
    return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
  }

  public String next() {
    return String();
  }

  public interface SpaceCharFilter {
    public boolean isSpaceChar(int ch);
  }

  public double readDouble() {
    int c = read();
    while (isSpaceChar(c)) {
      c = read();
    }
    int sgn = 1;
    if (c == '-') {
      sgn = -1;
      c = read();
    }
    double res = 0;
    while (!isSpaceChar(c) && c != '.') {
      if (c == 'e' || c == 'E') {
        return res * Math.pow(10, Int());
      }
      if (c < '0' || c > '9') {
        throw new InputMismatchException();
      }
      res *= 10;
      res += c - '0';
      c = read();
    }
    if (c == '.') {
      c = read();
      double m = 1;
      while (!isSpaceChar(c)) {
        if (c == 'e' || c == 'E') {
          return res * Math.pow(10, Int());
        }
        if (c < '0' || c > '9') {
          throw new InputMismatchException();
        }
        m /= 10;
        res += (c - '0') * m;
        c = read();
      }
    }
    return res * sgn;
  }
}

class OutputWriter {
  private final PrintWriter writer;

  public OutputWriter(OutputStream outputStream) {
    writer = new PrintWriter(
        new BufferedWriter(new OutputStreamWriter(outputStream)));
  }

  public OutputWriter(Writer writer) {
    this.writer = new PrintWriter(writer);
  }

  public void print(Object... objects) {
    for (int i = 0; i < objects.length; i++) {
      if (i != 0) {
        writer.print(' ');
      }
      writer.print(objects[i]);
    }
    writer.flush();
  }

  public void printLine(Object... objects) {
    print(objects);
    writer.println();
    writer.flush();
  }

  public void close() {
    writer.close();
  }

  public void flush() {
    writer.flush();
  }
}

class IOUtils {
  public static int[] readIntArray(InputReader in, int size) {
    int[] array = new int[size];
    for (int i = 0; i < size; i++)
      array[i] = in.Int();
    return array;
  }
}

/**
* TO SORT VIA TWO KEYS , HERE IT IS ACCORDING TO ASCENDING ORDER OF FIRST AND
* DESC ORDER OF SECOND
* LIST name-list 
* ARRAYLIST
* COPY PASTE
* 
* Collections.sort(list, (first,second) ->{
             if(first.con >second.con)
                 return -1;
             else if(first.con<second.con)
                 return 1;
             else {
                 if(first.index >second.index)
                     return 1;
                 else
                     return -1;
             }
             
         });
* 
*/

/**
* 


DECIMAL FORMATTER
Double k = in.readDouble();

System.out.println(k);
DecimalFormat df = new DecimalFormat("#.##");
System.out.print(df.format(k));
out.printLine(k);
* 
* */
