Problem: You are given two positive integers n (1 ≤ n ≤ 10^9) and k (1 ≤ k ≤ 100). Represent the number n as the sum of k positive integers of the same parity (have the same remainder when divided by 2).

In other words, find a_1, a_2, …, a_k such that all a_i>0, n = a_1 + a_2 + … + a_k and either all a_i are even or all a_i are odd at the same time.

If such a representation does not exist, then report it.

Input

The first line contains an integer t (1 ≤ t ≤ 1000) — the number of test cases in the input. Next, t test cases are given, one per line.

Each test case is two positive integers n (1 ≤ n ≤ 10^9) and k (1 ≤ k ≤ 100).

Output

For each test case print:

  * YES and the required values a_i, if the answer exists (if there are several answers, print any of them); 
  * NO if the answer does not exist. 



The letters in the words YES and NO can be printed in any case.

Example

Input


8
10 3
100 4
8 7
97 2
8 8
3 10
5 3
1000000000 9


Output


YES
4 2 4
YES
55 5 5 35
NO
NO
YES
1 1 1 1 1 1 1 1
NO
YES
3 1 1
YES
111111110 111111110 111111110 111111110 111111110 111111110 111111110 111111110 111111120

Solution (in JAVA):

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

public class pp1 {
    FastScanner in;
    PrintWriter out;
    class Graph{
        int V;
        ArrayList<Integer> adjlist[];
        Graph(int n){
            this.V = n;
            this.adjlist = new ArrayList[n];
            for(int i=0;i<this.V;i++){
                adjlist[i] = new ArrayList<>();
            }
        }
        void addEdge(int u, int v){
            adjlist[u].add(v);
            adjlist[v].add(u);
        }
        int dfs(int start, int dest, boolean[] vis, List<Integer> happy){
            vis[start]=true;
            int sum=0;
            boolean flag=false;
            for(int i=0;i<adjlist[start].size();i++){
                int b = adjlist[start].get(i);
                if(!vis[b]){
                    flag=true;
                    sum+=dfs(b, dest+1,vis, happy );
                }
            }
            int remain = dest-sum;
            happy.add(remain);
            return sum+1;
        }



    }

    List<Integer> []al;
    boolean [] visited;
    int [] parent;

    void bfs(int src,int dest,List<Integer> [] list){
        Queue<Integer> queue=new LinkedList<>();
        queue.add(src);
        parent[src]=-1;
        visited[src]=true;
        while(!queue.isEmpty()){
            int u=queue.poll();

            for(int v : al[u]){
                if(!visited[v]){
                    queue.add(v);
                    parent[v]=u;
                    visited[v]=true;
                    if(v==dest){
                        break;
                    }
                }
            }
        }
        List<Integer> edge=new ArrayList<>();
        edge.add(dest);
        int k=dest;
        while(parent[k]!=src && parent[k]!=-1){
            k=parent[k];
            edge.add(k);
        }
        edge.add(src);
        for(int i=1;i<edge.size();i++){

            int a=edge.get(i-1);
            int b=edge.get(i);
            list[a].add(b);
        }


    }

    long mod = 1000000007;

    int x = 500031;
    int[] a = new int[x];
    void solve() {
        int t = in.nextInt();

        while(t-->0){
            int n= in.nextInt();
            int k= in.nextInt();
            if(n%2!=0 && k%2==0){out.println("NO");continue;}
            if (n%2==0 && k%2!=0){
                if(n<2*k){
                    out.println("NO");
                    continue;
                }
                out.println("YES");
                for(int i=1;i<k;i++){
                    out.print("2 ");
                }
                out.println(n-2*(k-1));

            }
            else{
                if(n<k){
                    out.println("NO");
                    continue;
                }
                out.println("YES");
                for(int i=1;i<k;i++){
                    out.print("1 ");
                }
                out.println(n-(k-1));
            }


        }

    }


    public static void main(String[] args) {
        new pp1().runIO();
    }

    void run() {
        try {
            in = new FastScanner(new File("A.in"));
            out = new PrintWriter(new File("A.out"));
            solve();
            out.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }

    void runIO() {
        in = new FastScanner(System.in);
        out = new PrintWriter(System.out);
        solve();
        out.close();
    }

    class FastScanner {
        BufferedReader br;
        StringTokenizer st;

        public FastScanner(File f) {
            try {
                br = new BufferedReader(new FileReader(f));
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
        }

        public FastScanner(InputStream f) {
            br = new BufferedReader(new InputStreamReader(f));
        }

        String next() {
            while (st == null || !st.hasMoreTokens()) {
                String s = null;
                try {
                    s = br.readLine();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                if (s == null)
                    return null;
                st = new StringTokenizer(s);
            }
            return st.nextToken();
        }

        String nextLine() {
            try {
                return br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return null;
        }

        boolean hasMoreTokens() {
            while (st == null || !st.hasMoreTokens()) {
                String s = null;
                try {
                    s = br.readLine();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                if (s == null)
                    return false;
                st = new StringTokenizer(s);
            }
            return true;
        }

        int nextInt() {
            return Integer.parseInt(next());
        }

        long nextLong() {
            return Long.parseLong(next());
        }

        double nextDouble() {
            return Double.parseDouble(next());
        }
    }
}