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 static java.lang.Math.abs;

public class TP {

    // constants
    static final int MOD = (int) (1e9 + 7);
    static final int IMAX = 0x7fffffff;
    static final int IMIN = 0x80000000;
    static final long LMAX = 0x7fffffffffffffffL;
    static final long LMIN = -0x8000000000000000L;
    //debug
    private static final boolean oj = System.getProperty("ONLINE_JUDGE") != null;
    public static PrintWriter out;
    public static FastReader in;

    public static void main(String[] args) throws IOException {
        long s = System.currentTimeMillis();
        in = new FastReader();
        out = new PrintWriter(System.out);
//        out = new PrintWriter(new BufferedWriter(new FileWriter("whereami.out")));
        pre();
        int t = 1;
        t = ni();
        for (int i = 1; i <= t; i++) {
//            out.print("Case #" + i + ": ");
            solve();
        }
        out.flush();
        tr(System.currentTimeMillis() - s + "ms");
    }

//    private static void solve() {
//        int n = ni();
//        String S = ns();
//        char[] s = S.toCharArray();
//       while(true){
//
//       }
//
//    }

    private static void pre() {
    }

    private static void solve() {
        int n = ni();
        int[] a = na(n);
        Arrays.sort(a);
        long gcd = a[n - 1];
        int cnt = 0;
        int min = a[0], max = a[0];
        HashSet<Integer> set = new HashSet<>();
        for (int i = 0; i < n; i++) {
            if (a[i] > 0)
                gcd = gcd(gcd, a[i]);
            if (a[i] < 0) cnt++;
            min = min(min, a[i]);
            max = max(max, a[i]);
            set.add(a[i]);
        }
        if (cnt >= 1 || max / gcd > 300) {
            out.println("NO");
            return;
        }
        min = (int) min(min, gcd);
        int[] b = new int[300];
        int i = 0;
        for (i = 0; i < 300 && set.size() > 0; i++) {
            set.remove(min);
            b[i] = min;
            min += gcd;
        }
        b = Arrays.copyOf(b, i);
        if (check(b) && set.size() == 0) {
            out.println("YES");
            out.println(b.length);
            print(b);
//            out.println("DONE");
        }
    }

    private static boolean check(int[] b) {
        HashSet<Integer> set = new HashSet<>();
        for (int x : b) set.add(x);
        for (int i = 0; i < b.length; i++) {
            for (int j = i + 1; j < b.length; j++) {
                if (!set.contains(abs(b[i] - b[j]))) {
                    tr(abs(b[i] - b[j]));
                    return false;
                }
            }
        }
        return true;
    }

    /*

#include<bits/stdc++.h>
#define ll long long int
using namespace std;

ll dp[100010][110][2];
ll arr[100010];

void solve(){
   ll n,K; cin>>n>>K;
   for(int i=1;i<=n;i++) cin>>arr[i];
   for(int i=1;i<=n+3;i++) for(int j=0;j<=K+2;j++) dp[i][j][0]=dp[i][j][1]=-1e16;
   dp[n+1][K][0]=dp[n+1][K][1]=0;
   for(int idx=n;idx>=1;idx--){
       for(int k=0;k<=K;k++){
           dp[idx][k][0]=max(dp[idx+1][k][0],dp[idx+1][k+1][1]+arr[idx]*(k+1));
           dp[idx][k][1]=max(dp[idx][k][0],dp[idx+1][k][1]+arr[idx]*k);
       }
   }
   cout<<dp[1][0][0]<<endl;
}

int main(){
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    ll t; cin>>t;
    while(t--) solve();
}
     * */

    static int median(int[][] m, int r, int c) {
        int max = Integer.MIN_VALUE;
        int min = Integer.MAX_VALUE;

        for (int i = 0; i < r; i++) {
            if (m[i][0] < min) min = m[i][0];
            if (m[i][c - 1] > max) max = m[i][c - 1];
        }

        int desired = (r * c + 1) / 2;
        while (min < max) {
            int mid = min + (max - min) / 2;
            int place = 0;
            int get = 0;
            for (int i = 0; i < r; ++i) {
                get = Arrays.binarySearch(m[i], mid);
                if (get < 0)
                    get = abs(get) - 1;
                else {
                    while (get < m[i].length && m[i][get] == mid)
                        get += 1;
                }

                place = place + get;
            }

            if (place < desired)
                min = mid + 1;
            else
                max = mid;
        }
        return min;
    }

    public static int countGoodSubstrings(String _s) {
        int[] chars = new int[256];
        char[] s = _s.toCharArray();
        int n = s.length;
        if (n < 3) return 0;
        int cnt = 0;
        for (int i = 0; i < 3; i++) chars[s[i] - 'a']++;
        if (sum(chars) == 3) cnt++;
        for (int i = 3; i < n; i++) {
            chars[s[i - 3] - 'a']--;
            chars[s[i] - 'a']++;
            if (sum(chars) == 3) cnt++;
        }
        return cnt;
    }

    private static int sum(int[] chars) {
        int sum = 0;
        for (int aChar : chars) {
            if (aChar > 0)
                sum++;
        }
        return sum;
    }


    //input
    private static int ni() {
        return in.nextInt();
    }

    private static String ns() {
        return in.next();
    }

    private static int[] na(int n) {
        int[] a = new int[n];
        for (int i = 0; i < n; i++) a[i] = ni();
        return a;
    }

    private static long[] nal(int n) {
        long[] a = new long[n];
        for (int i = 0; i < n; i++) a[i] = nl();
        return a;
    }

    private static long nl() {
        return in.nextLong();
    }

    private static double nd() {
        return in.nextDouble();
    }

    private static void print(char[] a) {
        for (char x : a) out.print(x + " ");
        out.println();
    }

    private static void print(int[] a) {
        for (int x : a) out.print(x + " ");
        out.println();
    }

    private static void print(long[] a) {
        for (long x : a) out.print(x + " ");
        out.println();
    }

    // array util
    static void reverse(int[] a) {
        for (int i = 0, n = a.length, half = n / 2; i < half; ++i) {
            int swap = a[i];
            a[i] = a[n - i - 1];
            a[n - i - 1] = swap;
        }
    }

    static void reverse(long[] a) {
        for (int i = 0, n = a.length, half = n / 2; i < half; ++i) {
            long swap = a[i];
            a[i] = a[n - i - 1];
            a[n - i - 1] = swap;
        }
    }

    static void reverse(char[] a) {
        for (int i = 0, n = a.length, half = n / 2; i < half; ++i) {
            char swap = a[i];
            a[i] = a[n - i - 1];
            a[n - i - 1] = swap;
        }
    }

    static int[] copy(int[] a) {
        int[] ans = new int[a.length];
        for (int i = 0; i < a.length; ++i) ans[i] = a[i];
        return ans;
    }

    static long[] copy(long[] a) {
        long[] ans = new long[a.length];
        for (int i = 0; i < a.length; ++i) ans[i] = a[i];
        return ans;
    }

    static char[] copy(char[] a) {
        char[] ans = new char[a.length];
        for (int i = 0; i < a.length; ++i) ans[i] = a[i];
        return ans;
    }

    static int min(int... x) {
        if (x.length == 1) return x[0];
        if (x.length == 2) return Math.min(x[0], x[1]);
        if (x.length == 3) return Math.min(x[0], Math.min(x[1], x[2]));
        int min = x[0];
        for (int i = 1; i < x.length; ++i) if (x[i] < min) min = x[i];
        return min;
    }

    static long min(long... x) {
        if (x.length == 1) return x[0];
        if (x.length == 2) return Math.min(x[0], x[1]);
        if (x.length == 3) return Math.min(x[0], Math.min(x[1], x[2]));
        long min = x[0];
        for (int i = 1; i < x.length; ++i) if (x[i] < min) min = x[i];
        return min;
    }


    // math util

    static int max(int... x) {
        if (x.length == 1) return x[0];
        if (x.length == 2) return Math.max(x[0], x[1]);
        if (x.length == 3) return Math.max(x[0], Math.max(x[1], x[2]));
        return Arrays.stream(x).max().getAsInt();
    }

    static long max(long... x) {
        if (x.length == 1) return x[0];
        if (x.length == 2) return Math.max(x[0], x[1]);
        if (x.length == 3) return Math.max(x[0], Math.max(x[1], x[2]));
        long max = x[0];
        for (int i = 1; i < x.length; ++i) if (x[i] > max) max = x[i];
        return max;
    }

    static int pow(int a, int b) {
        if (a == 0) return 0;
        int ans = 1;
        while (b > 0) {
            if ((b & 1) > 0) ans *= a;
            a *= a;
            b >>= 1;
        }
        return ans;
    }

    static long pow(long a, int b) {
        if (a == 0) return 0;
        long ans = 1;
        while (b > 0) {
            if ((b & 1) > 0) ans *= a;
            a *= a;
            b >>= 1;
        }
        return ans;
    }

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

    static long modInverse(long n, int p) {
        return power(n, p - 2, p);
    }

    static long modInverse(int n, int p) {
        return power(n, p - 2, p);
    }

    static long nCrModPFermat(int n, int r, int p) {
        if (n < r)
            return 0;
        if (r == 0)
            return 1;
        int[] fac = new int[n + 1];
        fac[0] = 1;
        for (int i = 1; i <= n; i++)
            fac[i] = fac[i - 1] * i % p;
        return (fac[n] * modInverse(fac[r], p) % p * modInverse(fac[n - r], p) % p) % p;
    }

    static boolean isPrime(long n) {
        for (long i = 2; i * i <= n; i++) if (n % i == 0) return false;
        return true;
    }

    public static long gcd(long a, long b) {
        while (b != 0) {
            a %= b;
            long t = a;
            a = b;
            b = t;
        }
        return a;
    }

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

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

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

    public static int lowerBound(int[] a, int v) {
        int low = -1, high = a.length;
        while (high - low > 1) {
            int h = high + low >>> 1;
            if (a[h] >= v) {
                high = h;
            } else {
                low = h;
            }
        }
        return high;
    }

    public static int[] facs(int n, int[] primes) {
        int[] ret = new int[9];
        int rp = 0;
        for (int p : primes) {
            if (p * p > n) break;
            int i;
            i = 0;
            while (n % p == 0) {
                n /= p;
                i++;
            }
            if (i > 0) ret[rp++] = p;
        }
        if (n != 1) ret[rp++] = n;
        return Arrays.copyOf(ret, rp);
    }

    public static int[] sieveEratosthenes(int n) {
        if (n <= 32) {
            int[] primes = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31};
            for (int i = 0; i < primes.length; i++) {
                if (n < primes[i]) {
                    return Arrays.copyOf(primes, i);
                }
            }
            return primes;
        }

        int u = n + 32;
        double lu = Math.log(u);
        int[] ret = new int[(int) (u / lu + u / lu / lu * 1.5)];
        ret[0] = 2;
        int pos = 1;

        int[] isnp = new int[(n + 1) / 32 / 2 + 1];
        int sup = (n + 1) / 32 / 2 + 1;

        int[] tprimes = {3, 5, 7, 11, 13, 17, 19, 23, 29, 31};
        for (int tp : tprimes) {
            ret[pos++] = tp;
            int[] ptn = new int[tp];
            for (int i = (tp - 3) / 2; i < tp << 5; i += tp) ptn[i >> 5] |= 1 << (i & 31);
            for (int j = 0; j < sup; j += tp) {
                for (int i = 0; i < tp && i + j < sup; i++) {
                    isnp[j + i] |= ptn[i];
                }
            }
        }

        // 3,5,7
        // 2x+3=n
        int[] magic = {
                0, 1, 23, 2, 29, 24, 19, 3, 30, 27, 25, 11, 20, 8, 4, 13, 31, 22, 28, 18, 26, 10, 7, 12, 21,
                17, 9, 6, 16, 5, 15, 14
        };
        int h = n / 2;
        for (int i = 0; i < sup; i++) {
            for (int j = ~isnp[i]; j != 0; j &= j - 1) {
                int pp = i << 5 | magic[(j & -j) * 0x076be629 >>> 27];
                int p = 2 * pp + 3;
                if (p > n) break;
                ret[pos++] = p;
                if ((long) p * p > n) continue;
                for (int q = (p * p - 3) / 2; q <= h; q += p) isnp[q >> 5] |= 1 << q;
            }
        }

        return Arrays.copyOf(ret, pos);
    }

    private static int[][] uniqCount(int[] a) {
        int n = a.length;
        int p = 0;
        int[][] b = new int[n][];
        for (int i = 0; i < n; i++) {
            if (i == 0 || a[i] != a[i - 1]) b[p++] = new int[]{a[i], 0};
            b[p - 1][1]++;
        }
        return Arrays.copyOf(b, p);
    }

    private static long lcm(long a, long b) {
        return a * b / gcd(a, b);
    }

    public static int[][] enumPrimesAndLPF(int n) {
        int[] lpf = new int[n + 1];
        double lu = Math.log(n + 32);

        int tot = 0;
        int[] primes = new int[(int) ((n + 32) / lu + (n + 32) / lu / lu * 1.5)];

        for (int i = 2; i <= n; i++) {
            lpf[i] = i;
        }

        for (int p = 2, tmp; p <= n; p++) {
            if (lpf[p] == p) {
                primes[tot++] = p;
            }
            for (int i = 0; i < tot && primes[i] <= lpf[p] && (tmp = primes[i] * p) <= n; i++) {
                lpf[tmp] = primes[i];
            }
        }

        return new int[][]{Arrays.copyOf(primes, tot), lpf};
    }

    public static int[] enumPrimes(int n) {
        int[] lpf = new int[n + 1];
        double lu = Math.log(n + 32);

        int tot = 0;
        int[] primes = new int[(int) ((n + 32) / lu + (n + 32) / lu / lu * 1.5)];

        for (int i = 2; i <= n; i++) {
            lpf[i] = i;
        }

        for (int p = 2, tmp; p <= n; p++) {
            if (lpf[p] == p) {
                primes[tot++] = p;
            }
            for (int i = 0; i < tot && primes[i] <= lpf[p] && (tmp = primes[i] * p) <= n; i++) {
                lpf[tmp] = primes[i];
            }
        }

        return Arrays.copyOf(primes, tot);
    }

    static boolean isPrime(int n) {
        for (int i = 2; i * i <= n; i++) if (n % i == 0) return false;
        return true;
    }

    private static void tr(Object... o) {
        if (!oj) System.out.println(Arrays.deepToString(o));
    }

    public String isSubset(long[] a1, long[] a2, long n, long m) {
        HashMap<Long, Integer> a1Map = new HashMap<>();
        HashMap<Long, Integer> a2Map = new HashMap<>();
        for (long x : a1) {
            a1Map.putIfAbsent(x, 0);
            a1Map.put(x, 1 + a1Map.get(x));
        }
        for (long x : a2) {
            a2Map.putIfAbsent(x, 0);
            a2Map.put(x, 1 + a2Map.get(x));
        }
        for (Map.Entry<Long, Integer> entry : a2Map.entrySet()) {
            if (!a1Map.containsKey(entry.getKey()) || entry.getValue() > a1Map.get(entry.getKey())) {
                return "No";
            }
        }
        return "Yes";
    }

    public int countOccurence(int[] arr, int n, int k) {
        HashMap<Integer, Integer> map = new HashMap<>();
        for (int x : arr) {
            map.putIfAbsent(x, 0);
            map.put(x, 1 + map.get(x));
        }
        int cnt = 0;
        for (int x : map.values()) {
            if (x >= n / k) cnt++;
        }
        return cnt;
    }

    private float nf() {
        return (float) in.nextDouble();
    }

    //reader
    static class FastReader {
        BufferedReader br;
        StringTokenizer st;

        public FastReader() throws FileNotFoundException {
            br = new BufferedReader(new InputStreamReader(System.in));
//            br = new BufferedReader(new FileReader("whereami.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());
        }
    }

}