Problem: Ashish has two strings a and b, each of length n, and an integer k. The strings only contain lowercase English letters.

He wants to convert string a into string b by performing some (possibly zero) operations on a.

In one move, he can either 

  * choose an index i (1 ≤ i≤ n-1) and swap a_i and a_{i+1}, or 
  * choose an index i (1 ≤ i ≤ n-k+1) and if a_i, a_{i+1}, …, a_{i+k-1} are all equal to some character c (c ≠ 'z'), replace each one with the next character (c+1), that is, 'a' is replaced by 'b', 'b' is replaced by 'c' and so on. 



Note that he can perform any number of operations, and the operations can only be performed on string a. 

Help Ashish determine if it is possible to convert string a into b after performing some (possibly zero) operations on it.

Input

The first line contains a single integer t (1 ≤ t ≤ 10^5) — the number of test cases. The description of each test case is as follows.

The first line of each test case contains two integers n (2 ≤ n ≤ 10^6) and k (1 ≤ k ≤ n).

The second line of each test case contains the string a of length n consisting of lowercase English letters.

The third line of each test case contains the string b of length n consisting of lowercase English letters.

It is guaranteed that the sum of values n among all test cases does not exceed 10^6.

Output

For each test case, print "Yes" if Ashish can convert a into b after some moves, else print "No".

You may print the letters of the answer in any case (upper or lower).

Example

Input


4
3 3
abc
bcd
4 2
abba
azza
2 1
zz
aa
6 2
aaabba
ddddcc


Output


No
Yes
No
Yes

Note

In the first test case it can be shown that it is impossible to convert a into b.

In the second test case,

"abba" \xrightarrow{inc} "acca" \xrightarrow{inc} … \xrightarrow{inc} "azza".

Here "swap" denotes an operation of the first type, and "inc" denotes an operation of the second type.

In the fourth test case,

"aaabba" \xrightarrow{swap} "aaabab" \xrightarrow{swap} "aaaabb" \xrightarrow{inc} … \xrightarrow{inc} "ddaabb" \xrightarrow{inc} … \xrightarrow{inc} "ddddbb" \xrightarrow{inc} … \xrightarrow{inc} "ddddcc".

Solution (in JAVA):

Solution:
import java.util.*;
import java.io.*;

public class Main {
    static Scanner sc;
    static BufferedReader br;
    static PrintWriter out;

    public static void main(String[] args) throws Exception{
        sc = new Scanner(System.in);
        //   br=new BufferedReader(new InputStreamReader(System.in));
        out = new PrintWriter(System.out);

        int t = 1;
        // t = Integer.valueOf(br.readLine().split(" ")[0]);
        //seiveOfEri();
        t=sc.nextInt();

        while (t-- > 0) {
            forEachTestCase();
        }


        //   br.close();
        sc.close();
        out.close();
    }

    static void forEachTestCase() throws  Exception{
        int n=sc.nextInt();
        int k=sc.nextInt();
        String a=sc.next();
        String b=sc.next();
        int fre[]=new int[26];
        int fre2[]=new int[26];
        for(int i=0;i<n;i++){
            fre[a.charAt(i)-'a']++;
            fre2[b.charAt(i)-'a']++;
        }
        for (int i = 0; i <26 ; i++) {
            if(fre2[i]>fre[i]){
                out.println("NO");return;
            }
            fre[i]-=fre2[i];
            if(fre[i]%k!=0){
                out.println("NO");return;
            }
            if(i+1<26)fre[i+1]+=fre[i];
        }
        out.println("YES");
    }

    static void remove(TreeMap<Integer,Integer> tm,int key){
        int fre=tm.get(key);
        if(fre==1){
            tm.remove(key);
            return;
        }
        tm.put(key,fre-1);
    }
    static long mod = 998244353;


    static long[][] mul(long a[][],long b[][]){
        long ans[][]=new long[a.length][b[0].length];
        for (int i = 0; i <a.length ; i++) {
            for (int j = 0; j <b[0].length ; j++) {
                for (int k = 0; k <a[0].length ; k++) {
                    ans[i][j]=add(ans[i][j],mul(a[i][k],b[k][j]));
                }
            }
        }
        return ans;
    }
    static long add(long a, long b) {
        a %= mod;
        b %= mod;
        return (a + b) % mod;
    }

    static long mul(long a, long b) {
        a %= mod;
        b %= mod;
        return (a * b) % mod;
    }

    static long sub(long a, long b) {
        a %= mod;
        b %= mod;
        return (((a - b) % mod) + mod) % mod;
    }

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

    static long modPow(long a, long b) {
        long ans = 1;
        while (b > 0) {
            if (b % 2 == 1) {
                ans = mul(ans, a);
            }
            a = mul(a, a);
            b >>= 1;
        }
        return ans;
    }

    static long modInv(long a) {
        return modPow(a, mod - 2);
    }

    static long fact[],ifact[];
    static int maxFactSize=200001;
    static void  initFact(){
        fact=new long[maxFactSize];
        ifact=new long[maxFactSize];
        fact[0]=ifact[0]=1;
        for (int i = 1; i <maxFactSize ; i++) {
            fact[i]=mul(fact[i-1],i);
            ifact[i]=mul(ifact[i-1],modInv(i));
        }
    }

    static long nCr(int n,int r){
        if(n>r || n<0 || r<0)return 0;
        if(fact==null)initFact();
        return mul(fact[n],mul(ifact[n],ifact[r]));
    }

    static int seive[];
    static ArrayList<Integer> primes;
    static int seiveLength=2000001;
    static void seiveOfEri(){
        seive=new int[seiveLength];
        primes=new ArrayList<>();
        for (int i = 2; i <seiveLength ; i++) {
            if(seive[i]==0) {
                primes.add(i);
                for (int j = i; j < seiveLength; j += i) {
                    seive[j]=i;
                }
            }
        }
    }



    static class DSU{
        int n,par[],size[],connectedComponent;
        DSU(int n){
            this.n=n;
            par=new int[n];
            size=new int[n];
            connectedComponent=n;
            for(int i=0;i<n;i++){
                par[i]=i;
                size[i]=1;
            }
        }
        int root(int u){
            if(u==par[u]){
                return u;
            }
            return par[u]=root(par[u]);
        }
        boolean isConnected(int u,int v){
            u=root(u);
            v=root(v);
            if(u==v)return true;
            return false;
        }
        void union(int u,int v){
            u=root(u);
            v=root(v);
            if(u!=v){
                if(size[u]<size[v]){
                    int temp=u;
                    u=v;
                    v=temp;
                }
                size[u]+=size[v];
                par[v]=u;
                connectedComponent--;
            }
        }
        boolean oneComponent(){
            if(connectedComponent==1)return true;
            return false;
        }
    }

//    class SegmentTree{
//        class Node{
//           //update this
//        }
//        Node tree[];
//        SegmentTree(int n){
//            tree=new Node[4*n];
//        }
//        void update(int cur,int l,int r,int ind,int val){
//            if(l==r){
//                //update this
//                tree[cur]=new Node();
//                return;
//            }
//            int mid=(l+r)>>1;
//            if(mid>=ind)update(2*cur+1,l,mid,ind,val);
//            else update(2*cur+2,mid+1,r,ind,val);
//            tree[cur]=merge(tree[2*cur+1],tree[2*cur+2]);
//        }
//        Node merge(Node o1,Node o2){
//            //update this
//        }
//        Node query(int cur,int l,int r,int start,int end){
//            //update this
//            if(l>end || r<start)return new Node();
//            if(l>=start && r<=end)return tree[cur];
//            int mid=(l+r)>>1;
//            return merge(query(2*cur+1,l,mid,start,end),query(2*cur+2,mid+1,r,start,end));
//        }
//    }
}