Problem: Omkar has received a message from Anton saying "Your story for problem A is confusing. Just make a formal statement." Because of this, Omkar gives you an array a = [a_1, a_2, …, a_n] of n distinct integers. An array b = [b_1, b_2, …, b_k] is called nice if for any two distinct elements b_i, b_j of b, |b_i-b_j| appears in b at least once. In addition, all elements in b must be distinct. Can you add several (maybe, 0) integers to a to create a nice array b of size at most 300? If a is already nice, you don't have to add any elements.

For example, array [3, 6, 9] is nice, as |6-3|=|9-6| = 3, which appears in the array, and |9-3| = 6, which appears in the array, while array [4, 2, 0, 6, 9] is not nice, as |9-4| = 5 is not present in the array.

For integers x and y, |x-y| = x-y if x > y and |x-y| = y-x otherwise.

Input

Each test contains multiple test cases. The first line contains t (1 ≤ t ≤ 50), the number of test cases. Description of the test cases follows.

The first line of each test case contains a single integer n (2 ≤ n ≤ 100) — the length of the array a.

The second line of each test case contains n distinct integers a_1, a_2, ⋅⋅⋅, a_n (-100 ≤ a_i ≤ 100) — the elements of the array a.

Output

For each test case, output one line containing YES if Omkar can create a nice array b by adding elements to a and NO otherwise. The case of each letter does not matter, so yEs and nO will also be accepted.

If the first line is YES, output a second line containing a single integer k (n ≤ k ≤ 300). 

Then output one line containing k distinct integers b_1, b_2, ⋅⋅⋅, b_k (-10^9 ≤ b_i ≤ 10^9), the elements of the nice array b. b_1, b_2, ⋅⋅⋅, b_k can be in any order. For each a_i in a, a_i must appear at least once in b.

It can be proved that if Omkar can create such an array b, then he can also do so in a way that satisfies the above constraints.

If multiple solutions exist, you can print any. 

Example

Input


4
3
3 0 9
2
3 4
5
-7 3 13 -2 8
4
4 8 12 6


Output


yes
4
6 0 3 9
yEs
5
5 3 1 2 4
NO
Yes
6
8 12 6 2 4 10

Note

For the first case, you can add integers to a to receive the array b = [6, 0, 3, 9]. Note that |6-3| = |9-6| = |3-0| = 3 and 3 is in b, |6-0| = |9-3| = 6 and 6 is in b, and |9-0| = 9 is in b, so b is nice.

For the second case, you can add integers to a to receive the array b = [5, 3, 1, 2, 4]. We have that |2-1| = |3-2| = |4-3| = |5-4| = 1 is in b, |3-1| = |4-2| = |5-3| = 2 is in b, |4-1| = |5-2| = 3 is in b, and |5-1| = 4 is in b, so b is nice.

For the fourth case, you can add integers to a to receive the array b = [8, 12, 6, 2, 4, 10]. We have that |4-2| = |6-4| = |8-6| = |10-8| = |12-10| = 2 is in b, |6-2| = |8-4| = |10-6| = |12-8| = 4 is in b, |8-2| = |10-4| = |12-6| = 6 is in b, |10-2| = |12-4| = 8 is in b, and |12-2| = 10 is in b, so b is nice.

It can be proven that for all other test cases it is impossible to create a nice array b.

Solution (in JAVA):

Solution:
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Deque;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.Map;
import java.util.Queue;
import java.util.Scanner;
import java.util.Set;
import java.util.Vector;

public class Main{

	static class Pair{

		int x;
		int y;

		Pair(int x1,int y1){
			x=x1;
			y=y1;
		}
	}

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

	static long bigmod(int a,int b,int M){
		long ans=1;
		long reminder=a%M;
		while(b!=0){
			if(b%2==1){
				ans=(ans*reminder)%M;
			}
			reminder=(reminder*reminder)%M;
			b/=2;
		}
		return ans;
	}

	public static void main(String[] args){
		//System.out.println(gcd(5,6));
		Scanner ob=new Scanner(System.in);
		int t=ob.nextInt();
		while(t-->0){
			int n=ob.nextInt();
			int a[]=new int[n];
			Map<Integer,Integer> hs=new HashMap();
			Vector<Integer> v=new Vector();
			int k=0;
			int max=Integer.MIN_VALUE;
			for(int i=0;i<n;i++){
				int x=ob.nextInt();
				a[i]=x;
				max=Math.max(x,max);
				if(x<0)
				{
				k++;
				}
			}
			if(k>0){System.out.println("NO");}
			else{
				System.out.println("YES");
				System.out.println(max+1);
			for(int i=0;i<=max;i++){
				System.out.print(i+" ");
			}
				System.out.println();
			}
			

		}
		/*	
		int a[]=new int[4];
			a[0]=ob.nextInt();
			a[1]=ob.nextInt();
			a[2]=ob.nextInt();
			a[3]=ob.nextInt();
			int x=Math.max(a[0],a[1]);
			int y=Math.max(a[2],a[3]);
			Arrays.sort(a);
			if((a[a.length-1]+a[a.length-2])==(x+y)){System.out.println("YES");}
			else{
				System.out.println("NO");
			}
		}
		 */
		//System.out.println(sum);
		//System.out.println(2&1);
		//Vector<Pair> v=new Vector();
		//out:
		//while(t-->0){
		//int x=ob.nextInt();
		//int y=ob.nextInt();
		//Pair p=new Pair(x,y);
//v.add(p);
		//Map<Integer,Integer> hs1=new HashMap();
		//HashMap<Integer,Integer>hs2=new HashMap();
		//HashMap<Integer,Integer>hs3=new HashMap();
		/*Vector<Integer> v[]=new Vector[t+1];
			int a[]=new int[t];
			int b[]=new int[t];
			int c[]=new int[t];

			int count[]=new int[t+1];
			for(int i=0;i<t;i++){
				a[i]=ob.nextInt();
			}
			for(int i=0;i<t;i++){
				b[i]=ob.nextInt();
			}
			for(int i=0;i<t;i++){
				c[i]=ob.nextInt();
			}

			HashMap<Integer,Integer> map=new HashMap<>();
			for(int i=0;i<t;i++){
				map.put(b[c[i]-1],map.getOrDefault(b[c[i]-1],0)+1);
			}
			System.out.println(map);
			//System.out.println(count);
			long ans=0;
			for(int i=0;i<t;i++){
				ans+=a[i];
			}
			System.out.println(ans);*/
		//Vector<Integer>v=new Vector();
		//String s=ob.next();
		//long n=ob.nextLong();
		/*String s1="";
			for(int i=0;i<s.length();i++)
			{
			s1+='1';
			}
			//long x=(n1/Integer.parseInt(s1))*Integer.parseInt(s1);
			//n1-=Integer.parseInt(s1);
			 
			//System.out.println(x);
		 */
		//System.out.println(n1);
		//System.out.println("NO");
		/*
			for(int i=a.length-1;i>=0;i--){
				System.out.println(n);

				if(n%a[i]==0){
					System.out.println("YES");
					continue out;
				}
				//long q=n/a[i];
				n-=(a[i]);
				{
					for(int j=i;j>=0;j--){

						if(n%a[j]==0){
							System.out.println("YES");
							continue out;
						}
						long q=n/a[j];
						n-=(a[i]);

					}
				}
			}
			System.out.println(n);
			System.out.println("NO");
		 */
		//
		//System.out.println(count+1);
		//Arrays.sort(a);
		//Collections.sort(v);
		//for(int i=0;i<n;i++)
		//{
		//if(a[i]>a[0])
		//{
		//count++;
		//}
		//}
		//System.out.println(hs.size());
		//System.out.println(hs1);
		//
		//int max=0;
		//for(Map.Entry<Integer,Integer>e:hs1.entrySet())
		//{
		//max=Math.max(max,e.getValue());
		//v.add(e.getValue());
		//}
		//Collections.sort(v);
		//System.out.println(v.get(0));
		//System.out.println(a.length-v.get(v.size()-1));
		//int x=v.get(0);
		//	System.out.println(a.length-max);
		//}
		//System.out.println(v);
	}
}