This problem is different from the hard version. In this version Ujan makes exactly one exchange. You can hack this problem only if you solve both problems.

After struggling and failing many times, Ujan decided to try to clean up his house again. He decided to get his strings in order first.

Ujan has two distinct strings s and t of length n consisting of only of lowercase English characters. He wants to make them equal. Since Ujan is lazy, he will perform the following operation exactly once: he takes two positions i and j (1 ≤ i,j ≤ n, the values i and j can be equal or different), and swaps the characters s_i and t_j. Can he succeed?

Note that he has to perform this operation exactly once. He has to perform this operation.

Input

The first line contains a single integer k (1 ≤ k ≤ 10), the number of test cases.

For each of the test cases, the first line contains a single integer n (2 ≤ n ≤ 10^4), the length of the strings s and t. 

Each of the next two lines contains the strings s and t, each having length exactly n. The strings consist only of lowercase English letters. It is guaranteed that strings are different.

Output

For each test case, output "Yes" if Ujan can make the two strings equal and "No" otherwise.

You can print each letter in any case (upper or lower).

Example

Input


4
5
souse
houhe
3
cat
dog
2
aa
az
3
abc
bca


Output


Yes
No
No
No

Note

In the first test case, Ujan can swap characters s_1 and t_4, obtaining the word "house".

In the second test case, it is not possible to make the strings equal using exactly one swap of s_i and t_j.
// Java program For handling Input/Output 
import java.io.*; 
import java.util.*;
import java.math.*;
//import java.awt.*;

public class Main 
{ 
    Scanner sc;
    //actual logic
    void solve(){
        int t = ni();
        while(t-- > 0)
        {
            int n = ni();
            ns();
            String s1 = ns();
            String s2 = ns();
            int k = 0;
            char p1[] = new char[2];
            char p2[] = new char[2];
            for(int i = 0;i < n;i++)
            {
                if(s1.charAt(i) != s2.charAt(i))
                {
                    if(k < 2)
                    {
                        p1[k] = s1.charAt(i);
                        p2[k] = s2.charAt(i);
                    }
                    k++;
                }
            }
            if(k > 2)
                System.out.println("No");
            else
            {
                if(p1[0] == p1[1] && p2[0] == p2[1])
                    System.out.println("Yes");
                else
                    System.out.println("No");
            }
        }
    }

//constructor
    Main(){
        try{  
            sc = new Scanner(System.in);
        }catch(Exception e){
            System.out.println(e);
        }
    }


//main metohd
    public static void main(String[] args) 
    { 
     new Main().solve();
 }


//Utility methods
    //input an integer from scanner
 int ni()
 {
    int a = sc.nextInt();
    return a;
}
    //input a long from scanner
long nl()
{
    return sc.nextLong();
}
    //input a float from scanner
float nf(){
    float a = sc.nextFloat();
    return a;
}
    //input a double from scanner
double nd(){
    double a = sc.nextDouble();
    return a;
}
    //input a sentence from scanner
String ns(){
    return sc.nextLine();
}
    //converts a string to stringtokenizer
StringTokenizer nst(String s){
    return new StringTokenizer(s);
}
    //input an intger array
void ia(int a[]){
    for(int i = 0;i < a.length;i++)
        a[i] = sc.nextInt();
}
    //
void la(long a[]){
    for(int i = 0;i < a.length;i++)
        a[i] = sc.nextLong();
}
    //input a float array
void fa(float a[]){
    for(int i = 0;i < a.length;i++)
        a[i] = sc.nextFloat();
}
    //input a double array
void da(double a[]){
    for(int i = 0;i < a.length;i++)
        a[i] = sc.nextDouble();
}
    //input a string array either with all empty input or from scanner
void sa(String a[], boolean empty){
    if(empty)
    {
        for(int i = 0;i < a.length;i++)
        {
            a[i] = "";
        }
    }
    else
    {
        for(int i = 0;i < a.length;i++)
        {
            a[i] = ns();
        }
    }
}
    //input two dimensional integer array
void ida(int a[][], int n, int m)
{
    for(int i = 0;i < n;i++)
    {
        for(int j = 0;j < m;j++)
        {
            a[i][j] = ni();
        }
    }
}
    //input two dimentional long array
void lda(long a[][], int n, int m)
{
    for(int i = 0;i < n;i++)
    {
        for(int j = 0;j < m;j++)
        {
            a[i][j] = nl();
        }
    }
}
    //input two dimensional double array
void dda(double a[][], int n, int m)
{
    for(int i = 0;i < n;i++)
    {
        for(int j = 0;j < m;j++)
        {
            a[i][j] = nd();
        }
    }
}
    //convert string to integer
int stoi(String s){
    return Integer.parseInt(s);
}
    //convert string to double
double stod(String s){
    return Double.parseDouble(s);
}
    //find minimum in a long array
long lmin(long a[])
{
    long min = Long.MAX_VALUE;
    for(int i = 0;i < a.length;i++)
    {
        if(min > a[i])
            min = a[i];
    }
    return min;
}
    //find minimum in a integer array
int imin(int a[])
{
    int min = Integer.MAX_VALUE;
    for(int i = 0;i < a.length;i++)
    {
        if(min > a[i])
            min = a[i];
    }
    return min;
}
    //find maximum in a long array
long lmax(long a[])
{
    long max = Long.MIN_VALUE;
    for(int i = 0;i < a.length;i++)
    {
        if(max < a[i])
            max = a[i];
    }
    return max;
}
    //find maximum in an integer array
int imax(int a[])
{
    int max = Integer.MIN_VALUE;
    for(int i = 0;i < a.length;i++)
    {
        if(max < a[i])
            max = a[i];
    }
    return max;
}
    //check whether an element is present in an integer array by binary search
boolean ibs(int a[], int toFind)
{
    Arrays.sort(a);
    int min = 0;
    int max = a.length-1;
    boolean found = false;

    while(min <= max && !found)
    {
        int mid = min + (max-min)/2;
        if(a[mid] == toFind)
        {
           found = true;
       }
       else if(toFind > a[mid])
       {
        min = mid+1;
    }
    else
    {
        max = mid-1;
    }

}
return found;
}
    //check whether an element is present in a long array
boolean lbs(long a[], long toFind)
{
    Arrays.sort(a);
    int min = 0;
    int max = a.length-1;
    boolean found = false;

    while(min <= max && !found)
    {
        int mid = min + (max-min)/2;
        if(a[mid] == toFind)
        {
           found = true;
       }
       else if(toFind > a[mid])
       {
        min = mid+1;
    }
    else
    {
        max = mid-1;
    }

}
return found;
}

int stb(String s)
{
    int sum = 0;
    int k = 0;
    for(int i = s.length()-1;i >= 0;i--)
    {
        sum += stoi(s.charAt(i)+"") * Math.pow(2, k++);
    }
    return sum;
}

}