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.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.TreeSet;

public class Corona
{
static void merge(long arr[], int l, int m, int r) 
{ 
int n1 = m - l + 1; 
int n2 = r - m; 

long L[] = new long [n1]; 
long R[] = new long [n2]; 
for (int i=0; i<n1; ++i) 
    L[i] = arr[l + i]; 
for (int j=0; j<n2; ++j) 
    R[j] = arr[m + 1+ j]; 
int i = 0, j = 0; 
int k = l; 
while (i < n1 && j < n2) 
{ 
    if (L[i] <= R[j]) 
    { 
        arr[k] = L[i]; 
        i++; 
    } 
    else
    { 
        arr[k] = R[j]; 
        j++; 
    } 
    k++; 
} 
while (i < n1) 
{ 
    arr[k] = L[i]; 
    i++; 
    k++; 
} 
while (j < n2) 
{ 
    arr[k] = R[j]; 
    j++; 
    k++; 
} 
} 
static void sort(long arr[], int l, int r) 
{ 
if (l < r) 
{ 
    int m = (l+r)/2; 
    sort(arr, l, m); 
    sort(arr , m+1, r); 
    merge(arr, l, m, r); 
} 
}
//static PrintWriter out = new PrintWriter(System.out);
public static void main(String[] args) throws IOException 
{
try 
{
BufferInput in = new BufferInput();
StringBuilder sb = new StringBuilder();
int t = in.nextInt();
while(t-->0) {
	int n = in.nextInt();
	int k = in.nextInt();
	if(k==1) {
		sb.append("YES").append("\n").append(n).append("\n");
		continue;
	}
	if(k==n) 
	{
		sb.append("YES").append("\n");
		while(k>0) {
			sb.append("1 ");
			k--;
			n--;
		}
		sb.append("\n");
		continue;
	}
	ArrayList<Integer> a = new ArrayList<>();
	ArrayList<Integer> b = new ArrayList<>();
	int nn = n;
	int kk=k;
	while(k>1) 
	{
		a.add(1);
		n--;
		k--;
	}
	a.add(n);
	while(kk>1) 
	{
		b.add(2);
		nn-=2;
		kk--;
	}
	b.add(nn);
	int f=0;
	for(int i=0;i<a.size();i++)
	{
		if(a.get(i)>0&&a.get(i)%2!=0) continue;
		else f=1;
	}
	if(f==1) 
	{
		f=0;
		for(int i=0;i<b.size();i++) 
		{
			if(b.get(i)>0&&b.get(i)%2==0) continue;
			else f=1;
		}
		if(f==0) {
			sb.append("YES").append("\n");
			for(int i=0;i<b.size();i++) 
			{
				sb.append(b.get(i)+" ");
			}
			sb.append("\n");
		}
		else 
		{
			sb.append("NO").append("\n");
			
		}
	}
	else
	{
		sb.append("YES").append("\n");
		for(int i=0;i<a.size();i++) {
			sb.append(a.get(i)+" ");
		}
		sb.append("\n");
	}

}
System.out.print(sb);


}catch(Exception e) {}

}


static class BufferInput {

final private int BUFFER_SIZE = 1 << 16;

private DataInputStream din;

private byte[] buffer;

private int bufferPointer, bytesRead;

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

public BufferInput(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];
int cnt = 0, c;
while ((c = read()) != -1) {
	if (c == '\n')
		break;
	buf[cnt++] = (byte) c;
}
return new String(buf, 0, cnt);
}

public String nextString() throws IOException{

byte c = read();
while(Character.isWhitespace(c)){
	c = read();
}

StringBuilder builder = new StringBuilder();
builder.append((char)c);
c = read();
while(!Character.isWhitespace(c)){
	builder.append((char)c);
	c = read();
}

return builder.toString();
}

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 int[] nextIntArray(int n) throws IOException {
int arr[] = new int[n];
for(int i = 0; i < n; i++){
	arr[i] = nextInt();
}
return arr;
}

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 long[] nextLongArray(int n) throws IOException {
long arr[] = new long[n];
for(int i = 0; i < n; i++)
{
	arr[i] = nextLong();
}
return arr;
}


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();
}
}
}