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.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.*;


public class Codeforces1 {

	public static void main (String[] args) throws java.lang.Exception
	{
	BufferedReader br = new BufferedReader (new InputStreamReader(System.in));
	   int t = Integer.parseInt(br.readLine());
	   PrintWriter o = new PrintWriter(System.out);
	   while(t-->0)
	   {
	           
	             int n  = Integer.parseInt(br.readLine());
	             
	             String st1[] =br.readLine().trim().split(" ");
	             
	             long a[] = new long[n];
	             HashMap<Long,Long> ha = new HashMap<>();
	             ArrayList<Long> al = new ArrayList<>();
	             for(int i=0;i<n;i++)
	             {
	            	a[i] = Integer.parseInt(st1[i]); 
	            	ha.put(a[i],(long)1);
	            	al.add(a[i]);
	             }
	             
	             Queue<Long> q= new LinkedList<Long>();
	             
	            long temp=0;
	             boolean check = false;
	             for(int i=0;i<n-1;i++)
	             {
	            	 for(int j=i+1;j<n;j++)
	            	 {
	            		  
	            		 if(!ha.containsKey(Math.abs(a[j]-a[i])))
	            		 {
	            			  temp = Math.abs(a[j]- a[i]);
	            			
	            			  if(!ha.containsKey(temp))
	            			 {
	            				  ha.put(temp,(long)1);
	            		          q.add(temp);
	            			     al.add(temp);
	            			 if(al.size()>300)
	            			     {
	            				 check = true;
	            			 
	            			   break;
	            			 }
	            			 
	            			 }
	            		 }
	            	 }
	             }
	       
	        	   
	            	 
	            
	             while(!q.isEmpty())
	             {
	            	 if(al.size()>300)
	            	 {
	            		 check = true;
	            		 break;
	            	 }
	            	
	            	 
	            	 for(int i=0;i<q.size();i++)
	            	 {
	            		 long x = q.poll();
	            		 
	            		 for(int j=0;j<al.size();j++)
	            		 {
	            			 if(al.get(j)==x)
	            				 continue;
	            			 if(!ha.containsKey(Math.abs(al.get(j)-x)))
	            			 {
	            				 temp = Math.abs(al.get(j)-x);
	            				 if(!ha.containsKey(temp))
	            				 {
	            					 ha.put(temp,(long)1);
	            				
	            					 
	            				 q.add(temp);
	            				 al.add(temp);
	            		
	            				 
	            				 
	            				 if(al.size()>300)
	            				 {
	            					 check = true;
	            					 break;
	            				 }
	            				 }
	            				 
	            				 
	            			 }
	            		 }
	            		 if(check)
	            			 break;
	            	 }
	            	 if(check)
	            		 break;
	             }
	             
	             if(check)
	            	 o.println("NO");
	             else
	             {
	            	 o.println("Yes");
	            	 o.println(al.size());
	                  for(int i=0;i<al.size();i++)
	                  {
	            	      o.print(al.get(i)+" ");
	                    }
	                       o.println();
	             }
	             
	             o.flush();   
	   }
	  
	
	}
	
  
            
      
      
}