Problem: Given a permutation p of length n, find its subsequence s_1, s_2, …, s_k of length at least 2 such that:

  * |s_1-s_2|+|s_2-s_3|+…+|s_{k-1}-s_k| is as big as possible over all subsequences of p with length at least 2. 
  * Among all such subsequences, choose the one whose length, k, is as small as possible. 



If multiple subsequences satisfy these conditions, you are allowed to find any of them.

A sequence a is a subsequence of an array b if a can be obtained from b by deleting some (possibly, zero or all) elements.

A permutation of length n is an array of length n in which every element from 1 to n occurs exactly once.

Input

The first line contains an integer t (1 ≤ t ≤ 2 ⋅ 10^4) — the number of test cases. The description of the test cases follows.

The first line of each test case contains an integer n (2 ≤ n ≤ 10^5) — the length of the permutation p.

The second line of each test case contains n integers p_1, p_2, …, p_{n} (1 ≤ p_i ≤ n, p_i are distinct) — the elements of the permutation p.

The sum of n across the test cases doesn't exceed 10^5.

Output

For each test case, the first line should contain the length of the found subsequence, k. The second line should contain s_1, s_2, …, s_k — its elements.

If multiple subsequences satisfy these conditions, you are allowed to find any of them.

Example

Input


2
3
3 2 1
4
1 3 4 2


Output


2
3 1 
3
1 4 2 

Note

In the first test case, there are 4 subsequences of length at least 2:

  * [3,2] which gives us |3-2|=1. 
  * [3,1] which gives us |3-1|=2. 
  * [2,1] which gives us |2-1|=1. 
  * [3,2,1] which gives us |3-2|+|2-1|=2. 



So the answer is either [3,1] or [3,2,1]. Since we want the subsequence to be as short as possible, the answer is [3,1].

Solution (in JAVA):

Solution:

import java.util.*;
import java.lang.*;
import java.io.*;

public class feb20 {

//	            ***                          ++                      
//             +=-==+                      +++=-                     
//            +-:---==+                   *+=----=                   
//           +-:------==+               ++=------==                  
//           =-----------=++=========================                
//          +--:::::---:-----============-=======+++====             
//          +---:..:----::-===============-======+++++++++           
//          =---:...---:-===================---===++++++++++         
//          +----:...:-=======================--==+++++++++++        
//          +-:------====================++===---==++++===+++++      
//         +=-----======================+++++==---==+==-::=++**+     
//        +=-----================---=======++=========::.:-+*****    
//       +==::-====================--:  --:-====++=+===:..-=+*****   
//       +=---=====================-...  :=..:-=+++++++++===++*****  
//       +=---=====+=++++++++++++++++=-:::::-====+++++++++++++*****+ 
//      +=======++++++++++++=+++++++============++++++=======+****** 
//      +=====+++++++++++++++++++++++++==++++==++++++=:...  . .+**** 
//     ++====++++++++++++++++++++++++++++++++++++++++-.     ..-+**** 
//     +======++++++++++++++++++++++++++++++++===+====:.    ..:=++++ 
//     +===--=====+++++++++++++++++++++++++++=========-::....::-=++* 
//     ====--==========+++++++==+++===++++===========--:::....:=++*  
//     ====---===++++=====++++++==+++=======-::--===-:.  ....:-+++   
//     ==--=--====++++++++==+++++++++++======--::::...::::::-=+++    
//     ===----===++++++++++++++++++++============--=-==----==+++     
//     =--------====++++++++++++++++=====================+++++++     
//     =---------=======++++++++====+++=================++++++++     
//     -----------========+++++++++++++++=================+++++++    
//     =----------==========++++++++++=====================++++++++  
//     =====------==============+++++++===================+++==+++++ 
//     =======------==========================================++++++

	// created by : Nitesh Gupta

	public static void main(String[] args) throws Exception {

//		first();
//		sec();
//		third();
		four();
//			fif();
//			six();
	}

	private static void first() throws Exception {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String[] scn = (br.readLine()).trim().split(" ");
		StringBuilder sb = new StringBuilder();

		int n = Integer.parseInt(scn[0]);

		int count = 0;
		for (int i = 0; i <= n + 1; i++) {
			count += 1;
			int j = i;
			sb.append(i + " " + j + " \n");
		}
		for (int i = 1; i <= n + 1; i++) {
			count += 1;
			int j = i - 1;
			sb.append(i + " " + j + " \n");
		}
		for (int j = 1; j <= n + 1; j++) {
			count += 1;
			int i = j - 1;
			sb.append(i + " " + j + " \n");
		}

		System.out.println(count);
		System.out.println(sb);
		return;
	}

	private static void sec() throws Exception {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String[] scn = (br.readLine()).trim().split(" ");
		StringBuilder sb = new StringBuilder();
		int n = Integer.parseInt(scn[0]);
		long[] arr = new long[n];
		scn = (br.readLine()).trim().split(" ");
		HashMap<Long, Integer> map = new HashMap<>();
		for (int i = 0; i < n; i++) {
			arr[i] = Long.parseLong(scn[i]);
			map.put(arr[i], map.getOrDefault(arr[i], 0) + 1);
		}

		TreeSet<Long> present = new TreeSet<>();
		TreeSet<Long> set = new TreeSet<>();

		long start = 0;
		boolean can = true;
		long[] ans = new long[n];
		for (int i = 0; i < n; i++) {
			while (map.containsKey(start) && map.get(start) > 0) {
				present.add(start);
				start += 1;
			}

			if (start != arr[i]) {
				if (!set.isEmpty()) {
					ans[i] = set.pollFirst();
				} else {
					ans[i] = start;
					start += 1;
				}
			}
			int f = map.remove(arr[i]);
			if (f > 1) {
				map.put(arr[i], f - 1);
			} else {
				if (present.contains(arr[i])) {
					present.remove(arr[i]);
					set.add(arr[i]);
				}

			}
		}
		TreeSet<Long> chck = new TreeSet<>();
		for (long i = 0; i <= n; i++) {
			chck.add(i);
		}
		can = true;
		for (int i = 0; i < n; i++) {
			chck.remove(ans[i]);
			if (chck.first() == arr[i]) {

			} else {
				can = false;
				break;
			}
		}
		if (!can) {
			sb.append("-1");
		} else {
			for (long ele : ans) {
				sb.append(ele + " ");
			}
		}

		System.out.println(sb);
		return;
	}

	private static void third() throws Exception {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String[] scn = (br.readLine()).trim().split(" ");
		int t = Integer.parseInt(scn[0]);
		StringBuilder sb = new StringBuilder();

		while (t-- > 0) {
			scn = (br.readLine()).trim().split(" ");
			int n = Integer.parseInt(scn[0]);
			int x = Integer.parseInt(scn[1]);
			long[] arr = new long[n];
			scn = (br.readLine()).trim().split(" ");
			long sum = 0;
			int f = n, s = -1;
			boolean all = true;
			for (int i = 0; i < n; i++) {
				arr[i] = Long.parseLong(scn[i]);
				arr[i] %= x;
				sum += arr[i];
				sum %= x;
				if (arr[i] != 0) {
					f = Math.min(f, i);
					s = Math.max(s, i);
					all = false;
				}
			}

			int max = -1;
			if (sum != 0) {
				max = n;
			} else {
				if (all) {
					max = -1;
				} else {
					max = n - Math.min(f + 1, n - s);
				}
			}

			sb.append(max);
			sb.append("\n");
		}
		System.out.println(sb);
		return;
	}

	private static void four() throws Exception {

		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String[] scn = (br.readLine()).trim().split(" ");
		int t = Integer.parseInt(scn[0]);
		StringBuilder sb = new StringBuilder();

		while (t-- > 0) {
			scn = (br.readLine()).trim().split(" ");
			int n = Integer.parseInt(scn[0]);
			long[] arr = new long[n];
			scn = (br.readLine()).trim().split(" ");
			for (int i = 0; i < n; i++) {
				arr[i] = Long.parseLong(scn[i]);
			}
			int[] peak = new int[n];
			peak[0] = 1;
			peak[n - 1] = 1;
			int count = 2;
			for (int i = 1; i < n - 1; i++) {
				if (arr[i] < arr[i + 1] && arr[i] < arr[i - 1]) {
					peak[i] = 1;
					count += 1;
				}
				if (arr[i] > arr[i + 1] && arr[i] > arr[i - 1]) {
					peak[i] = 1;
					count += 1;
				}

			}
			sb.append(count + "\n");
			for (int i = 0; i < n; i++) {
				if (peak[i] == 1) {
					sb.append(arr[i] + " ");
				}
			}

			sb.append("\n");
		}
		System.out.println(sb);
		return;
	}

	private static void fif() throws Exception {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String[] scn = (br.readLine()).trim().split(" ");
		int t = Integer.parseInt(scn[0]);
		StringBuilder sb = new StringBuilder();

		while (t-- > 0) {
			scn = (br.readLine()).trim().split(" ");
			int n = Integer.parseInt(scn[0]);
			long[] arr = new long[n];
			scn = (br.readLine()).trim().split(" ");
			for (int i = 0; i < n; i++) {
				arr[i] = Long.parseLong(scn[i]);
			}

			sb.append("\n");
		}
		System.out.println(sb);
		return;
	}

	private static void six() throws Exception {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String[] scn = (br.readLine()).trim().split(" ");
		int t = Integer.parseInt(scn[0]);
		StringBuilder sb = new StringBuilder();

		while (t-- > 0) {
			scn = (br.readLine()).trim().split(" ");
			int n = Integer.parseInt(scn[0]);
			long[] arr = new long[n];
			scn = (br.readLine()).trim().split(" ");
			for (int i = 0; i < n; i++) {
				arr[i] = Long.parseLong(scn[i]);
			}

			sb.append("\n");
		}
		System.out.println(sb);
		return;
	}

	public static void sort(long[] arr) {
		int n = arr.length;
		for (int i = 0; i < n; i++) {
			int idx = (int) Math.random() * n;
			long temp = arr[i];
			arr[i] = arr[idx];
			arr[idx] = temp;
		}
		Arrays.sort(arr);
	}

	public static void print(long[][] dp) {
		for (long[] a : dp) {
			for (long ele : a) {
				System.out.print(ele + " ");
			}
			System.out.println();
		}
	}

}