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.*;

import java.util.*;






public class Codeforce{


    static FastReader fs = new FastReader();

    public static void main(String[] args) {
        int t = fs.nextInt();
        
        while(t-- >0){
            int k = fs.nextInt();
            int[] arr = fs.readArray(k);
            int min = min(arr), max = max(arr);
            ArrayList<Integer> a= new ArrayList<>();
            for(int i=Math.min(min,1);i<max+1;i++)a.add(i);
            boolean c = true;
            for(int i=0;i<a.size();i++){
                for(int j=0;j<a.size();j++){
                    if(i==j)continue;
                    if(!a.contains(Math.abs(a.get(i)-a.get(j)))){
                        c = false;
                        break;
                    }
                }

            }
            if(c){
                System.out.println("YES\n"+a.size());
                for(int i:a)System.out.print(i+" ");
                System.out.println();
            }else System.out.println("NO");


        }
    }

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

    public static void sieve(int[] arr){
        
        for(int i=2;i<arr.length;i++){
            if(arr[i]==0){
                if((long)i*(long)i>arr.length)break;
                for( int j=i*i;j<arr.length;j+=i){
                    arr[j]=1;
                }
            }
        }
 
    }

    
    public static boolean isPrime(int val){
        int[] arr = new int[1000001];
        sieve(arr);
        if(arr[val]==0) return true;
        return false;

    }

    public static boolean isPrime(long val){
        if(val==1) return false;
        if(val<4) return true;
        if(val%2==0) return false;
        for(long i=3;i*i<=val;i+=2){
            if(val%i==0){
                return false;
            }
        }
        return true;
    }


    public static int isplaindrome(StringBuilder b){
        for(int i=0,g=b.length()-1;i<b.length()/2;i++,g--){
            if(i>=g)break;
            if(b.charAt(i)!=b.charAt(g)){ return i;}
        }
        return -1;
    }

    public static  void sort(int[] arr){
        ArrayList<Integer> list = new ArrayList<>();
        for(int i:arr) list.add(i);
        Collections.sort(list);
        int index =0;
        for(int i:list) {arr[index]=i; index++;}
    }

    public static  void sort(char[] arr){
        ArrayList<Character> list = new ArrayList<>();
        for(char i:arr) list.add(i);
        Collections.sort(list);
        int index =0;
        for(char i:list) {arr[index]=i; index++;}
    }

    public static  void sort(long[] arr){
        ArrayList<Long> list = new ArrayList<>();
        for(long i:arr) list.add(i);
        Collections.sort(list);
        int index =0;
        for(long i:list) {arr[index]=i; index++;}
    }

    public static  void reverse(int[] arr){
        ArrayList<Integer> list = new ArrayList<>();
        for(int i:arr) list.add(i);
        Collections.sort(list, Collections.reverseOrder());
        int index =0;
        for(int i:list) {arr[index]=i; index++;}
    }

    static public void printArray(int[] arr){
        for(int i=0;i<arr.length;i++) System.out.print(arr[i]+" ");
        System.out.println();

    }


    static public long max(long[] arr){
        long max = Long.MIN_VALUE;
        for(long l:arr){
            if(l>max) max = l;
        }
        return max;
    }
    static public int min(int[] arr){
        int min = Integer.MAX_VALUE;
        for(int l:arr){
            if(l<min) min = l;
        }
        return min;
    }
    static public int max(int[] arr){
        int max = Integer.MIN_VALUE;
        for(int l:arr){
            if(l>max) max = l;
        }
        return max;
    }
    

    static public char max(char[] arr){
        char max = Character.MIN_VALUE;
        for(char l:arr){
            if(l>max) max = l;
        }
        return max;
    }
}


class Data implements Comparable<Data>{
    int  x;
    int  a;
    public Data(int x, int a){
        this.x = x;
        this.a = a;
    }
    @Override
    public int compareTo(Data o) {
        if(x>o.x) return 1;
        else if(x<o.x) return -1;
        else return 0;
    }
}

class FastReader{
    private BufferedReader br;
    private StringTokenizer str;

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

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

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

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

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

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

        return s;
    }

    public int[] readArray(int n){
        int[] arr = new int[n];
        for(int i =0;i<n;i++) arr[i] = nextInt();
        return arr;
    }

    public long[] readArrayL(int n){
        long[] arr = new long[n];
        for(int i =0;i<n;i++) arr[i] = nextLong();
        return arr;
    }
    public double[] readArrayD(int n){
        double[] arr = new double[n];
        for(int i =0;i<n;i++) arr[i] = nextDouble();
        return arr;
    }

}