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.lang.reflect.Array;
import java.math.BigInteger;
import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;

public class Solution {
  private static int readInt() throws Exception {
    return Integer.parseInt(br.readLine());
  }

  private static long readLong() throws Exception {
    return Long.parseLong(br.readLine());
  }

  public static int[] readIntArray() throws Exception {
    String line = br.readLine();
    if (line == null || line.isEmpty()) return null;
    String[] lines = line.split(" ");
    int n = Integer.parseInt(lines[0]);
    int[] nums = new int[n];
    for (int i = 0; i < n; i++)
      nums[i] = Integer.parseInt(lines[i + 1]);
    return nums;
  }

  public static int[] readIntArray(int n) throws Exception {
    int[] nums = new int[n];
    String[] lines = br.readLine().split(" ");
    for (int i = 0; i < n; i++)
      nums[i] = Integer.parseInt(lines[i]);
    return nums;
  }

  public static long[] readLongArray(int n) throws Exception {
    long[] nums = new long[n];
    String[] lines = br.readLine().split(" ");
    for (int i = 0; i < n; i++)
      nums[i] = Long.parseLong(lines[i]);
    return nums;
  }

  public static String[] readStringArray(int n) throws Exception {
    String[] nums = new String[n];
    for (int i = 0; i < n; i++)
      nums[i] = br.readLine();
    return nums;
  }

  public static void printArrayInline(int[] nums) throws Exception {
    for (int i = 0; i < nums.length - 1; i++) {
      bw.write(nums[i] + " ");
    }
    bw.write(nums[nums.length - 1] + "\n");
  }

  public static void printArrayInline(long[] nums) throws Exception {
    for (int i = 0; i < nums.length - 1; i++) {
      bw.write(nums[i] + " ");
    }
    bw.write(nums[nums.length - 1] + "\n");
  }

  public static <T> void printListInLine(List<T> nums) throws Exception {
    for (int i = 0; i < nums.size() - 1; i++) {
      bw.write(nums.get(i).toString() + " ");
    }
    bw.write(nums.get(nums.size() - 1) + "\n");
  }

  public static <T> void printListMultiLine(List<T> nums) throws Exception {
    for (T num : nums) {
      bw.write(num.toString() + "\n");
    }
  }

  public static void printArrayMultiLine(int[] nums) throws Exception {
    for (int num : nums) {
      bw.write(num + "\n");
    }
  }

  public static int[] makeRandomArray(int size, int lower, int upper) {
    Random random = new Random(System.currentTimeMillis());
    int[] nums = new int[size];
    for (int i = 0; i < size; i++)
      nums[i] = random.nextInt(upper - lower + 1) + lower;
    return nums;
  }
  public static long[] makeRandomLongArray(int size, int lower, int upper) {
    Random random = new Random(System.currentTimeMillis());
    long[] nums = new long[size];
    for (int i = 0; i < size; i++)
      nums[i] = random.nextInt(upper - lower + 1) + lower;
    return nums;
  }

  static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
  static PrintWriter bw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
//  static {
//    try {
//      String env = System.getProperty("env-jay");
//      if (env != null && env.equals("jay")) {
//        br = new BufferedReader(new FileReader("src/input.txt"));
//        bw = new PrintWriter(new BufferedWriter(new FileWriter("src/output.txt", false)));
//      }
//    } catch (Throwable e) {
//
//    }
//  }
//
//
//  private static void test() throws Exception {
//    try {
//      String env = System.getProperty("env-jay");
//      if (env != null && env.equals("jay")) {
//        var output = new BufferedReader(new FileReader("src/output.txt"));
//        var expected = new BufferedReader(new FileReader("src/expected.txt"));
//        String ans;
//        int line = 0;
//        while ((ans = expected.readLine()) != null && !ans.isEmpty()) {
//          line++;
//          String guess = output.readLine();
//          if (guess == null || guess.isEmpty()) {
//            System.err.println(String.format(
//                    "Line[%d] There is no guess.\nAnswer:[%s]"
//                    , line, ans));
//            System.exit(-1);
//          }
//          if (!ans.equals(guess)) {
//            System.err.println(String.format(
//                    "Line[%d], Wrong guess.\nAnswer:[%s]\nGuess:[%s]"
//                    , line, ans, guess));
//            System.exit(-2);
//          }
//        }
//      }
//    } catch (Throwable e) {
//
//    }
//  }

  public static void main(String[] args) throws Exception {
    int testCases = readInt();
    for (int iter = 1; iter <= testCases; iter++) {
      int n = readInt();
      var nums = readIntArray(n);
      var ans = solve(nums);
      if(ans == null) bw.println("NO");
      else {
        bw.println("YES");
        bw.println(ans.length);
        printArrayInline(ans);
      }
    }
    bw.flush();
    bw.close();
    br.close();
    //test();
  }
  private static int[] solve(int[] arr) {
    int n = arr.length;
    Set<Integer> diffs = new HashSet<>();
    Set<Integer> nums = new HashSet<>();
    for(int i = 0; i < n; i ++) {
      nums.add(arr[i]);
      for(int j = i + 1; j < n; j ++) {
        diffs.add(Math.abs(arr[j] - arr[i]));
      }
    }
    Set<Integer> missing = diffs.stream().filter(one -> !nums.contains(one)).collect(Collectors.toSet());
    while(!missing.isEmpty() && nums.size() <= 300) {
      for(var num : missing) {
        for(var k : nums) {
          diffs.add(Math.abs(k - num));
        }
        nums.add(num);
      }

      missing = diffs.stream().filter(one -> !nums.contains(one)).collect(Collectors.toSet());
    }
    if(missing.isEmpty() && nums.size() <= 300) return nums.stream().mapToInt(one -> one).toArray();
    return null;
  }
}