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.*;
    import java.math.*;
    import java.lang.*;
     
     //@Manan Parmar

    public class Solution2 implements Runnable {


        public void run() {
            
        InputReader sc = new InputReader(System.in);
        PrintWriter out = new PrintWriter(System.out);
          
        
        int t=sc.nextInt();
        while(t--!=0)
        {
            int n=sc.nextInt(),a[]=new int[n];
            ArrayList<Integer> b=new ArrayList<Integer>();
            boolean c[]=new boolean[102],d=false;;
            for(int i=0;i<n;i++)
            {
                a[i]=sc.nextInt();
                if(a[i]>=0)
                {
                    c[a[i]]=true;
                    b.add(a[i]);
                }
                else
                    d=true;
            }
            if(d)
                out.println("NO");
            else
            {   
                out.println("YES");
                for(int i=0;i<b.size();i++)
                {
                    for(int j=0;j<b.size();j++)
                    {
                        if(i!=j)
                        {
                            int x=Math.abs(b.get(i)-b.get(j));
                            if(c[x])
                            {

                            }
                            else
                            {
                                c[x]=true;
                                b.add(x);
                            }
                        }
                    }
                }
                out.println(b.size());
                for(int y:b)
                    out.println(y);
            }
        }

        
        out.close();
        }
        
     

    //========================================================================
        boolean isPrime(int n) 
        { 
            // Corner case 
            if (n <= 1) 
                return false; 
      
            // Check from 2 to n-1 
            for (int i = 2; i < n; i++) 
                if (n % i == 0) 
                    return false; 
      
            return true; 
        } 
        int lcm(int number1, int number2) {
            if (number1 == 0 || number2 == 0) {
                return 0;
            }
            int absNumber1 = Math.abs(number1);
            int absNumber2 = Math.abs(number2);
            int absHigherNumber = Math.max(absNumber1, absNumber2);
            int absLowerNumber = Math.min(absNumber1, absNumber2);
            int lcm = absHigherNumber;
            while (lcm % absLowerNumber != 0) {
                lcm += absHigherNumber;
            }
            return lcm;
        }
        void quickSort(int a[],int l,int r)
        {
            if(l<r)
            {
                int pindex=partition(a,l,r);
                quickSort(a,l,pindex-1);
                quickSort(a,pindex+1,r);
            }

        }
        int partition(int a[],int l,int r)
        {
            int pivot = a[r],pindex=l;
            for(int i=l;i<r;i++)
            {
                if(a[i]<pivot)
                {
                    int temp=a[i];
                    a[i]=a[pindex];
                    a[pindex]=temp;
                    pindex++;
                }
            }
            int temp1=a[r];
            a[r]=a[pindex];
            a[pindex]=temp1;
            return pindex;
        }
        int binarySearch(int arr[], int x) 
        { 
            int l = 0, r = arr.length - 1; 
            while (l <= r) { 
                int m = l + (r - l) / 2; 
      
                // Check if x is present at mid 
                if (arr[m] >= x)
                    if(m!=0&&arr[m-1]<x) 
                        return m;
                    else if(m==0)
                        return m; 
      
                // If x greater, ignore left half 
                if (arr[m] < x) 
                    l = m + 1; 
      
                // If x is smaller, ignore right half 
                else
                    r = m - 1; 
            } 
      
            // if we reach here, then element was 
            // not present 
            return -1; 
        } 
        boolean check(char a,char b)
        {
            if(a==b)
                return true;
            else
                return false;
        }
        long binarySearch(long arr[], long x) 
        { 
            int l = 0, r = arr.length - 1,q=0; 
            while (l<=r) { 
                int m = l + (r - l) / 2; 
                if (arr[l] >=x) 
                {
                    q=1;
                    return l; 
                }
                if (arr[m] < x) 
                    l=m+1; 
                else
                    r=m;
            } 
            return -1;
        }

        static class InputReader {
            private InputStream stream;
            private byte[] buf = new byte[1024];
            private int curChar;
            private int numChars;
            private SpaceCharFilter filter;
            private BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
     
            public InputReader(InputStream stream) {
                this.stream = stream;
            }
           
            public int read() {
                if (numChars==-1)
                    throw new InputMismatchException();
               
                if (curChar >= numChars) {
                    curChar = 0;
                    try {
                        numChars = stream.read(buf);
                    }
                    catch (IOException e) {
                        throw new InputMismatchException();
                    }
                   
                    if(numChars <= 0)              
                        return -1;
                }
                return buf[curChar++];
            }
         
            public String nextLine() {
                String str = "";
                try {
                    str = br.readLine();
                }
                catch (IOException e) {
                    e.printStackTrace();
                }
                return str;
            }
            public int nextInt() {
                int c = read();
               
                while(isSpaceChar(c))
                    c = read();
               
                int sgn = 1;
               
                if (c == '-') {
                    sgn = -1;
                    c = read();
                }
               
                int res = 0;
                do {
                    if(c<'0'||c>'9')
                        throw new InputMismatchException();
                    res *= 10;
                    res += c - '0';
                    c = read();
                }
                while (!isSpaceChar(c));
               
                return res * sgn;
            }
           
            public long nextLong() {
                int c = read();
                while (isSpaceChar(c))
                    c = read();
                int sgn = 1;
                if (c == '-') {
                    sgn = -1;
                    c = read();
                }
                long res = 0;
               
                do {
                    if (c < '0' || c > '9')
                        throw new InputMismatchException();
                    res *= 10;
                    res += c - '0';
                    c = read();
                }
                while (!isSpaceChar(c));
                    return res * sgn;
            }
           
            public double nextDouble() {
                int c = read();
                while (isSpaceChar(c))
                    c = read();
                int sgn = 1;
                if (c == '-') {
                    sgn = -1;
                    c = read();
                }
                double res = 0;
                while (!isSpaceChar(c) && c != '.') {
                    if (c == 'e' || c == 'E')
                        return res * Math.pow(10, nextInt());
                    if (c < '0' || c > '9')
                        throw new InputMismatchException();
                    res *= 10;
                    res += c - '0';
                    c = read();
                }
                if (c == '.') {
                    c = read();
                    double m = 1;
                    while (!isSpaceChar(c)) {
                        if (c == 'e' || c == 'E')
                            return res * Math.pow(10, nextInt());
                        if (c < '0' || c > '9')
                            throw new InputMismatchException();
                        m /= 10;
                        res += (c - '0') * m;
                        c = read();
                    }
                }
                return res * sgn;
            }
           
            public String readString() {
                int c = read();
                while (isSpaceChar(c))
                    c = read();
                StringBuilder res = new StringBuilder();
                do {
                    res.appendCodePoint(c);
                    c = read();
                }
                while (!isSpaceChar(c));
               
                return res.toString();
            }
         
            public boolean isSpaceChar(int c) {
                if (filter != null)
                    return filter.isSpaceChar(c);
                return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
            }
         
            public String next() {
                return readString();
            }
           
            public interface SpaceCharFilter {
                public boolean isSpaceChar(int ch);
            }
        }

        public static void main(String args[]) throws Exception {
            new Thread(null, new Solution2(),"Main",1<<27).start();
        }
    }