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 org.w3c.dom.css.CSSImportRule;
import org.w3c.dom.ls.LSOutput;

import javax.naming.PartialResultException;
import javax.print.DocFlavor;
import javax.print.attribute.HashAttributeSet;
import javax.sql.rowset.serial.SQLOutputImpl;
import javax.swing.text.DefaultEditorKit;
import javax.swing.text.MutableAttributeSet;
import java.awt.image.AreaAveragingScaleFilter;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.sql.SQLOutput;
import java.util.*;
import java.math.*;
import java.lang.reflect.Array;
import java.math.*;
import java.security.*;
import java.text.*;
import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.ArrayList;
public class Main {
    static class Reader {
        final private int BUFFER_SIZE = 1 << 16;
        private DataInputStream din;
        private byte[] buffer;
        private int bufferPointer, bytesRead;

        public Reader() {
            din = new DataInputStream(System.in);
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public Reader(String file_name) throws IOException {
            din = new DataInputStream(new FileInputStream(file_name));
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public String readLine() throws IOException {
            byte[] buf = new byte[10000]; // line length
            int cnt = 0, c;
            while ((c = read()) != -1) {
                if (c == '\n')
                    break;
                buf[cnt++] = (byte) c;
            }
            return new String(buf, 0, cnt);
        }

        public int nextInt() throws IOException {
            int ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do {
                ret = ret * 10 + c - '0';
            } while ((c = read()) >= '0' && c <= '9');

            if (neg)
                return -ret;
            return ret;
        }

        public long nextLong() throws IOException {
            long ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do {
                ret = ret * 10 + c - '0';
            } while ((c = read()) >= '0' && c <= '9');
            if (neg)
                return -ret;
            return ret;
        }

        public double nextDouble() throws IOException {
            double ret = 0, div = 1;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();

            do {
                ret = ret * 10 + c - '0';
            } while ((c = read()) >= '0' && c <= '9');

            if (c == '.') {
                while ((c = read()) >= '0' && c <= '9') {
                    ret += (c - '0') / (div *= 10);
                }
            }

            if (neg)

                return -ret;
            return ret;
        }

        private void fillBuffer() throws IOException {
            bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
            if (bytesRead == -1)
                buffer[0] = -1;
        }

        private byte read() throws IOException {
            if (bufferPointer == bytesRead)
                fillBuffer();
            return buffer[bufferPointer++];
        }

        public void close() throws IOException {
            if (din == null)
                return;
            din.close();
        }
    }

    /* Used for sorting in different order based on different data*/
    class Node implements Comparable<Node> {
        int num;
        long weight;

        public Node(int num, long weight) {
            this.num = num;
            this.weight = weight;
        }

        @Override
        public int compareTo(Node n1) {
            if (this.weight == n1.weight) {
                return 0;
            }
            if (this.weight > n1.weight) {
                return 1;
            } else {
                return -1;
            }
        }
    }

    /*Graph Utility to create or implements graph operation*/
    class Graph {
        private int vertex;
        private ArrayList<Node> gList[];
        private int edges;

        public Graph() {
        }

        @SuppressWarnings("unchecked")
        public Graph(int vertex, int edges) {
            this.vertex = vertex;
            this.edges = edges;
            gList = new ArrayList[vertex + 1];
            for (int i = 1; i <= vertex; i++) {
                gList[i] = new ArrayList<Node>();
            }
        }

        public void addDoubleEdge(int start, int end, long weight) {
            Node n1 = new Node(end, weight);
            Node n2 = new Node(start, weight);
            gList[start].add(n1);
            gList[end].add(n2);
        }

        public void addSingleEdge(int start, int end, long weight) {
            Node n1 = new Node(end, weight);
            gList[start].add(n1);
        }
    }

    /*Class is used to compare from of two elements*/
    static class Comp {
        public int max(int first, int second) {
            if (first > second) {
                return first;
            } else {
                return second;
            }
        }

        public long max(long first, long second) {
            if (first > second) {
                return first;
            } else {
                return second;
            }
        }

        public int min(int first, int second) {
            if (first > second) {
                return second;
            } else {
                return first;
            }
        }

        public long min(long first, long second) {
            if (first > second) {
                return second;
            } else {
                return first;
            }
        }

        public int binarySearch(int arr[], int number) {
            int len = arr.length;
            int index = findElement(arr, 0, len - 1, number);
            return index;
        }

        public int binarySearch(long arr[], long number) {
            int len = arr.length;
            int index = findElement(arr, 0, len - 1, number);
            return index;
        }

        public int findElement(int arr[], int low, int high, int number) {
            if (high >= 1) {
                int mid = low + (high - 1) / 2;
                if (arr[mid] == number) {
                    return mid;
                }
                if (arr[mid] > number) {
                    return findElement(arr, low, mid - 1, number);
                } else {
                    return findElement(arr, mid + 1, high, number);
                }
            } else {
                return -1;
            }
        }

        public int findElement(long arr[], int low, int high, long number) {
            if (high >= 1) {
                int mid = low + (high - 1) / 2;
                if (arr[mid] == number) {
                    return mid;
                }
                if (arr[mid] > number) {
                    return findElement(arr, low, mid - 1, number);
                } else {
                    return findElement(arr, mid + 1, high, number);
                }
            } else {
                return -1;
            }
        }
    }

    /*Class is used to find gcd of all given number*/
    public static class GCD {
        public int find(int first, int second) {
            if (first == second) {
                return first;
            }
            if (first > second) {
                return prime(second, first);
            } else {
                return find(first, second);
            }
        }

        public long find(long first, long second) {
            if (first == second) {
                return first;
            }
            if (first > second) {
                return prime(second, first);
            } else {
                return prime(first, second);
            }
        }

        public int prime(int f, int s) {
            if (s % f == 0) {
                return f;
            } else {
                int x = s / f;
                return prime(x, f);
            }
        }

        public long prime(long f, long s) {
            if (s % f == 0) {
                return f;
            } else {
                long x = s / f;
                return prime(x, f);
            }
        }
    }

    public static void main(String[] args) throws IOException {
        Reader in = new Reader();
        int t=in.nextInt();
        while(t>0){
            int n=in.nextInt();
            int []arr = new int [n];
            HashSet<Integer> hs = new HashSet<>();
            ArrayList<Integer> list=new ArrayList<>();
            for(int i=0;i<n;i++){
                arr[i]=in.nextInt();
                hs.add(arr[i]);
                list.add(arr[i]);
            }
            for(int i=0;i<n-1;i++){
                for(int j=0;j<n;j++){
                    int x=Math.abs(arr[i]-arr[j]);
                    if(!hs.contains(x)){
                        list.add(x);
                        hs.add(x);
                    }
                }
            }
            //System.out.println(hs);
            int total=hs.size();
            while(total<=300){
                boolean flag=true;
                ArrayList<Integer> diff=new ArrayList<>();
                for(int i=0;i<list.size();i++){
                    for(int j=i+1;j<list.size();j++){
                        int val=Math.abs(list.get(i)-list.get(j));
                        if(!hs.contains(val)){
                            hs.add(val);
                            diff.add(val);
                            flag=false;
                            total++;
                        }
                    }
                }
                if(flag==true){
                    break;
                }else{
                    for(int i=0;i<diff.size();i++){
                        list.add(diff.get(i));
                    }
                }
            }
            if(total<=300){
                System.out.println("YES");
                System.out.println(hs.size());
                for(int i=0;i<list.size();i++){
                    System.out.print(list.get(i)+" ");
                }
                System.out.println();
            }else{
                System.out.println("NO");
            }
            t--;
        }
    }

    public static int hcf(int n1, int n2) {
        if (n2 != 0)
            return hcf(n2, n1 % n2);
        else
            return n1;
    }

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