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].
import java.util.*;
public class Solutions {
	static int MAX=Integer.MAX_VALUE;
	static int MIN=Integer.MIN_VALUE;
	static Scanner scr=new Scanner(System.in);
	public static void main(String[] args) {
		int t=read();
		while(t-->0) {
			solve();
		}
	}
	static ArrayList<Integer>list;
	static void solve() {
		int n=read();
		list=N();
		for(int i=0;i<n;i++) {
			int x=read();
			while(list.size()>=2) {
				int s=len(list);
				if(list.get(s-2)<list.get(s-1)==list.get(s-1)<x) {
					list.remove(s-1);
				}else {
					break;
				}
			}
			list.add(x);
		}
		println(list.size());
		printList(list);
	}
	static ArrayList<Integer>N(){
		return new ArrayList<Integer>();
	}
	static int maxInArray(int a[]) {
		int max=-1;int n=len(a);
		for(int i=0;i<n;i++) {
			max=Math.max(max,a[i]);
		}
		return max;
	}
	static int minInArray(int a[]) {
		int min=MAX;int n=len(a);
		for(int i=0;i<n;i++) {
			min=Math.min(min,a[i]);
		}
		return min;
	}
	static int sumOfArray(int a[]) {
		int sum=0;
		for(int i=0;i<len(a);i++) {
			sum+=a[i];
		}
		return sum;
	}
	static char[] charArray(String s) { 
		return s.toCharArray();
	}
	static int[] sort(int a[]) {
		Arrays.sort(a);
		return a;
	}
	static ArrayList<Integer>sort(ArrayList<Integer>a){
		Collections.sort(a);
		return a;
	}
	static String reverse(String s) {
		String res="";
		for(int i=s.length()-1;i>=0;i--) {
			res+=s.charAt(i);
		}
		return res;
	}static ArrayList<Integer>reverse (ArrayList<Integer>a) {
		ArrayList<Integer>b=new ArrayList<Integer>();
		for(int i=a.size()-1;i>=0;i--) {
			b.add(a.get(i));
		}
		return b;
	}
	static int[] reverse(int a[]) {
		int b[]=new int[a.length];;
		int index=0;
		for(int i=a.length-1;i>=0;i--) {
			b[index]=a[i];
			index++;
		}
		return b;
	}
	static int gcd(int a,int b) {
		if(b==0) {
			return a;
		}
		return gcd(b,a%b);
	}
	static long gcd(long a,long b) {
		if(b==0) {
			return a;
		}
		return gcd(b,a%b);
	}
	static void swap(int a[],int i,int j) {
		int temp=a[i];
		a[i]=a[j];
		a[j]=temp;
	}
	static char[] cha(String s) {
		return s.toCharArray();
	}
	static int len(String s) {
		return s.length();
	}
	static int len(int a[]) {
		return a.length;
	}
	static int len(long a[]) {
		return a.length;
	}
	static int len(ArrayList<Integer>a) {
		return a.size();
	}
	static long abs(long a) {
		return Math.abs(a);
	}static int abs(int a) {
		return Math.abs(a);
	}
	static long min(long a,long b) {
		return Math.min(a, b);
	}static long max(long a,long b) {
		return Math.max(a, b);
	}
	static void print(int a) {
		System.out.print(a+" ");
	}static void print(long a) {
		System.out.print(a+" ");
	}static void print(String a) {
		System.out.print(a);
	}static void println(int a) {
		System.out.println(a);
	}static void println(long a) {
		System.out.println(a);
	}static void println(String a) {
		System.out.println(a);
	}
	static void println() {
		System.out.println();
	}
	static void println(char []c) {
		for(int i=0;i<c.length;i++) {
			System.out.print(c[i]);
		}
		println();
	}
	static int read() {
		return scr.nextInt();
	}
	static String readS() {
		return scr.next();
	}
	static long readL() {
		return scr.nextLong();
	}
	static int[]readIntArray(int n){
//		int n=read();
		int []a=new int[n];
		for(int i=0;i<n;i++) {
			a[i]=scr.nextInt();
		}
		return a;
	}static long[]readLongArray(int n){
		long []a=new long[n];
		for(int i=0;i<n;i++) {
			a[i]=scr.nextLong();
		}
		return a;
	}
	static void printArray(int a[]) {
		int n=a.length;
		for(int i=0;i<n;i++) {
			print(a[i]);
		}
	}
	static void printList(ArrayList<Integer>a) {
		for(Integer i:a) {
			print(i);
		}
	}
}
//class pair{
//	int first;
//	int second;
//	pair(int first,int second){
//		this.first=first;
//		this.second=second;
//	}
//}
