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.IOException;
    import java.io.InputStream;
    import java.io.InputStreamReader;
    import java.io.PrintWriter;
    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.Collections;
    import java.util.Comparator;
    import java.util.HashMap;
    import java.util.HashSet;
    import java.util.List;
    import java.util.Map;
    import java.util.Set;
    import java.util.StringTokenizer;
    import java.util.TreeMap;
    import java.util.TreeSet;

    public class Main implements Runnable {
        int n, m, k;
        static boolean use_n_tests = true;
        long mod = 998244353L;
        int[] mark;
        Graph graph;

        void solve(FastScanner in, PrintWriter out, int testNumber) {
            n = in.nextInt();
            int[] a = in.nextArray(n);
            for (int x : a) {
                if (x < 0) {
                    out.println("NO");
                    return;
                }
            }
            Arrays.sort(a);
            int mx = a[n - 1];
            out.println("YES");
            out.println(mx + 1);
            for (int i = 0; i <= mx; i++) {
                out.print(i + " ");
            }
            out.println();

        }


        public static class FW {
            public static void add(long[] t, int i, long value) {
                for (; i < t.length; i |= i + 1)
                    t[i] += value;
            }
            public static long sum(long[] t, int i) {
                long res = 0;
                for (; i >= 0; i = (i & (i + 1)) - 1)
                    res += t[i];
                return res;
            }

            public static void add(long[] t, int a, int b, long value) {
                add(t, a, value);
                add(t, b + 1, -value);
            }
        }


        // ****************************** template code ***********
        long binpow(long a, int b) {
            long res = 1;
            while (b != 0) {
                if (b % 2 == 0) {
                    b /= 2;
                    a *= a;
                    a %= mod;
                }

                b--;
                res *= a;
                res %= mod;
            }
            return res;
        }

        List<Integer> getGidits(long n) {
            List<Integer> res = new ArrayList<>();
            while (n != 0) {
                res.add((int) (n % 10L));
                n /= 10;
            }
            return res;
        }

        List<Integer> generatePrimes(int n) {
            List<Integer> res = new ArrayList<>();
            boolean[] sieve = new boolean[n + 1];
            for (int i = 2; i <= n; i++) {
                if (!sieve[i]) {
                    res.add(i);
                }
                if ((long) i * i <= n) {
                    for (int j = i * i; j <= n; j += i) {
                        sieve[j] = true;
                    }
                }
            }
            return res;
        }

        int ask(int l, int r) {
            if (l >= r) {
                return -1;
            }
            System.out.printf("? %d %d\n", l + 1, r + 1);
            System.out.flush();
            return in.nextInt() - 1;
        }

        static int stack_size = 1 << 27;

        class Mod {
            long mod;

            Mod(long mod) {
                this.mod = mod;
            }

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

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

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

            long div(long a, long b) {
                a = mod(a);
                b = mod(b);
                return (a * inv(b)) % mod;
            }

            public long inv(long r) {
                if (r == 1)
                    return 1;
                return ((mod - mod / r) * inv(mod % r)) % mod;
            }

            private long mod(long a) {
                return a % mod;
            }
        }

        static class Coeff {
            long mod;
            long[][] C;
            long[] fact;
            boolean cycleWay = false;

            Coeff(int n, long mod) {
                this.mod = mod;
                fact = new long[n + 1];
                fact[0] = 1;
                for (int i = 1; i <= n; i++) {
                    fact[i] = i;
                    fact[i] %= mod;
                    fact[i] *= fact[i - 1];
                    fact[i] %= mod;
                }
            }

            Coeff(int n, int m, long mod) {
                // n > m
                cycleWay = true;
                this.mod = mod;
                C = new long[n + 1][m + 1];
                for (int i = 0; i <= n; i++) {
                    for (int j = 0; j <= Math.min(i, m); j++) {
                        if (j == 0 || j == i) {
                            C[i][j] = 1;
                        } else {
                            C[i][j] = C[i - 1][j - 1] + C[i - 1][j];
                            C[i][j] %= mod;
                        }
                    }
                }
            }

            public long C(int n, int m) {
                if (cycleWay) {
                    return C[n][m];
                }
                return fC(n, m);
            }

            private long fC(int n, int m) {
                return (fact[n] * inv(fact[n - m] * fact[m] % mod)) % mod;
            }

            private long inv(long r) {
                if (r == 1)
                    return 1;
                return ((mod - mod / r) * inv(mod % r)) % mod;
            }
        }

        class Pair {
            int first;
            long second;

            Pair(int f, long s) {
                first = f;
                second = s;
            }

            public int getFirst() {
                return first;
            }

            public long getSecond() {
                return second;
            }
        }

        class MultisetTree<T> {
            int size = 0;

            TreeMap<T, Integer> mp = new TreeMap<>();

            void add(T x) {
                mp.merge(x, 1, Integer::sum);
                size++;
            }

            void remove(T x) {
                if (mp.containsKey(x)) {
                    mp.merge(x, -1, Integer::sum);
                    if (mp.get(x) == 0) {
                        mp.remove(x);
                    }
                    size--;
                }
            }

            boolean contains(T x) {
                return mp.containsKey(x);
            }

            T greatest() {
                return mp.lastKey();
            }

            T smallest() {
                return mp.firstKey();
            }

            int size() {
                return size;
            }

            int diffSize() {
                return mp.size();
            }
        }

        class Multiset<T> {
            int size = 0;

            Map<T, Integer> mp = new HashMap<>();

            void add(T x) {
                mp.merge(x, 1, Integer::sum);
                size++;
            }

            boolean contains(T x) {
                return mp.containsKey(x);
            }

            void remove(T x) {
                if (mp.containsKey(x)) {
                    mp.merge(x, -1, Integer::sum);
                    if (mp.get(x) == 0) {
                        mp.remove(x);
                    }
                    size--;
                }
            }

            int size() {
                return size;
            }

            int diffSize() {
                return mp.size();
            }
        }

        static class Range {
            int l, r;
            int id;

            public int getL() {
                return l;
            }

            public int getR() {
                return r;
            }

            public Range(int l, int r, int id) {
                this.l = l;
                this.r = r;
                this.id = id;
            }
        }

        static class Array {
            static Range[] readRanges(int n, FastScanner in) {
                Range[] result = new Range[n];
                for (int i = 0; i < n; i++) {
                    result[i] = new Range(in.nextInt(), in.nextInt(), i);
                }
                return result;
            }

            static List<List<Integer>> intInit2D(int n) {
                List<List<Integer>> res = new ArrayList<>();
                for (int i = 0; i < n; i++) {
                    res.add(new ArrayList<>());
                }
                return res;
            }

            static boolean isSorted(Integer[] a) {
                for (int i = 0; i < a.length - 1; i++) {
                    if (a[i] > a[i + 1]) {
                        return false;
                    }
                }
                return true;
            }

            static public long sum(int[] a) {
                long sum = 0;
                for (int x : a) {
                    sum += x;
                }
                return sum;
            }

            static public long sum(long[] a) {
                long sum = 0;
                for (long x : a) {
                    sum += x;
                }
                return sum;
            }

            static public long sum(Integer[] a) {
                long sum = 0;
                for (int x : a) {
                    sum += x;
                }
                return sum;
            }

            static public int min(Integer[] a) {
                int mn = Integer.MAX_VALUE;
                for (int x : a) {
                    mn = Math.min(mn, x);
                }
                return mn;
            }

            static public int min(int[] a) {
                int mn = Integer.MAX_VALUE;
                for (int x : a) {
                    mn = Math.min(mn, x);
                }
                return mn;
            }

            static public int max(Integer[] a) {
                int mx = Integer.MIN_VALUE;
                for (int x : a) {
                    mx = Math.max(mx, x);
                }
                return mx;
            }

            static public int max(int[] a) {
                int mx = Integer.MIN_VALUE;
                for (int x : a) {
                    mx = Math.max(mx, x);
                }
                return mx;
            }

            static public int[] readint(int n, FastScanner in) {
                int[] out = new int[n];
                for (int i = 0; i < out.length; i++) {
                    out[i] = in.nextInt();
                }
                return out;
            }
        }

        class Graph {
            List<List<Integer>> graph;

            Graph(int n) {
                create(n);
            }

            private void create(int n) {
                List<List<Integer>> graph = new ArrayList<>();
                for (int i = 0; i < n; i++) {
                    graph.add(new ArrayList<>());
                }
                this.graph = graph;
            }

            void read(int m, FastScanner in) {
                for (int i = 0; i < m; i++) {
                    int v = in.nextInt() - 1;
                    int u = in.nextInt() - 1;
                    graph.get(v).add(u);
                }
            }

            void readBi(int m, FastScanner in) {
                for (int i = 0; i < m; i++) {
                    int v = in.nextInt() - 1;
                    int u = in.nextInt() - 1;
                    graph.get(v).add(u);
                    graph.get(u).add(v);
                }
            }
        }

        class FastScanner {
            BufferedReader br;
            StringTokenizer st;

            public FastScanner(InputStream io) {
                br = new BufferedReader(new InputStreamReader(io));
            }

            public String line() {
                String result = "";
                try {
                    result = br.readLine();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                return result;
            }

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

            public char[] nextc() {
                return next().toCharArray();
            }

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

            public int[] nextArray(int n) {
                int[] res = new int[n];
                for (int i = 0; i < n; i++) {
                    res[i] = in.nextInt();
                }
                return res;
            }

            public long[] nextArrayL(int n) {
                long[] res = new long[n];
                for (int i = 0; i < n; i++) {
                    res[i] = in.nextLong();
                }
                return res;
            }

            public Long[] nextArrayL2(int n) {
                Long[] res = new Long[n];
                for (int i = 0; i < n; i++) {
                    res[i] = in.nextLong();
                }
                return res;
            }


            public Integer[] nextArray2(int n) {
                Integer[] res = new Integer[n];
                for (int i = 0; i < n; i++) {
                    res[i] = in.nextInt();
                }
                return res;
            }

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

        }

        void run_t_tests() {
            int t = in.nextInt();
            int i = 0;
            while (t-- > 0) {
                solve(in, out, i++);
            }
        }

        void run_one() {
            solve(in, out, -1);
        }

        @Override
        public void run() {
            in = new FastScanner(System.in);
            out = new PrintWriter(System.out);
            if (use_n_tests) {
                run_t_tests();
            } else {
                run_one();
            }
            out.close();
        }

        static FastScanner in;
        static PrintWriter out;

        public static void main(String[] args) throws InterruptedException {
            Thread thread = new Thread(null, new Main(), "", stack_size);
            thread.start();
            thread.join();
        }
    }