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

 public class Test{

        static FastReader scan;
        

        static void solve(){
            int n=scan.nextInt();
            int []arr=new int[n];
            ArrayList<Integer>al=new ArrayList<>();
            Set<Integer>set=new HashSet<>();

            int flag=0;
            for(int i=0;i<n;i++){
                al.add(scan.nextInt());
                set.add(al.get(i));
                if(al.get(i)<0)flag=1;
            }

            if(flag==1){
                System.out.println("NO");
                return;
            }

            System.out.println("YES");
            System.out.println(101);
            for(int i=0;i<=100;i++){
                System.out.print(i+" ");
            }
            System.out.println();
            return;
            

            /*while(al.size()<=300){
                if(function(al,set)){
                    System.out.println("YES");
                    System.out.println(al.size());
                    for(int i=0;i<al.size();i++){
                        System.out.print(al.get(i)+" ");
                    }
                    System.out.println();
                    return;
                }
            }

            System.out.println("NO");*/
            

            
            
        }

        static boolean function(ArrayList<Integer>al,Set<Integer>set){
            for(int i=0;i<al.size();i++){
                if(al.size()>300){   
                    return false;
                }

                for(int j=i+1;j<al.size();j++){
                    int temp=Math.abs(al.get(j)-al.get(i));
                    if(!set.contains(temp)){
                    // System.out.println(temp);
                        al.add(temp);
                        set.add(temp);
                        i=0;
                        return false;
                    }

                }

            }
                return true;
        }

        public static void main (String[] args) throws java.lang.Exception{
            scan=new FastReader();
            /*al=new ArrayList<>();
            findLex();*/
            // System.out.println(al);
            int t=scan.nextInt();
            while(t-->0){
                solve();
            }
        }

        /*static void solveA(){
            int n=scan.nextInt();
            String str=scan.next();


            for(int i=0;i<al.size();i++){
                if(str.indexOf(al.get(i))==-1){
                    System.out.println(al.get(i));
                    return;
                }
            }


        }

        static void findLex(){
            for(char i='a';i<='z';i++){
                al.add(i+"");
            }
            
            
            for(char i='a';i<='z';i++){
                for(char j='a';j<='z';j++){
                    al.add(i+""+j+"");
                }
            }

            for(char i='a';i<='z';i++){
                for(char j='a';j<='z';j++){
                    for(char k='a';k<='z';k++){
                        al.add(i+""+j+""+k+"");
                    }
                }
            }    
            
        }*/

        static class FastReader {
            BufferedReader br;
            StringTokenizer st;

            public FastReader()
            {
                br = new BufferedReader(
                    new InputStreamReader(System.in));
            }

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

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

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

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

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

        static class Pair implements Comparable<Pair>{
            long wt;
            long idx;
            Pair(long x,long y){
                this.wt=x;
                this.idx=y;
            }
            @Override
            public int compareTo(Pair x){
                return (int)(this.wt-x.wt);
            }

            public String toString(){
                return "( "+wt+" "+idx+" )";
            }
        }        

        static void printLong(long []arr){
            for(long x:arr)System.out.print(x+" ");
        }

        static void printInt(int []arr){
            for(int x:arr)System.out.print(x+" ");
        }

        static void scanInt(int []arr){
            for(int i=0;i<arr.length;i++){
                arr[i]=scan.nextInt();
            }
        }

        static void scanLong(long []arr){
            for(int i=0;i<arr.length;i++){
                arr[i]=scan.nextLong();
            }
        }

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

        static long power(long x, long y, long mod){
            long res = 1; 
        
            x = x % mod; 
         
            if (x == 0)
              return 0; 
         
            while (y > 0){              
                if ((y & 1) != 0)
                res = (res * x) % mod;
              
                y = y >> 1; 
                x = (x * x) % mod;
            }
                return res;
        }

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

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

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

        static long mminvprime(long a, long b,long mod) {
            return power(a, b - 2,mod);
        }
}