description: During the hypnosis session, Nicholas suddenly remembered a positive integer n, which doesn't contain zeros in decimal notation. 
  
  Soon, when he returned home, he got curious: what is the maximum number of digits that can be removed from the number so that the number becomes not prime, that is, either composite or equal to one?
  
  For some numbers doing so is impossible: for example, for number 53 it's impossible to delete some of its digits to obtain a not prime integer. However, for all n in the test cases of this problem, it's guaranteed that it's possible to delete some of their digits to obtain a not prime number.
  
  Note that you cannot remove all the digits from the number.
  
  A prime number is a number that has no divisors except one and itself. A composite is a number that has more than two divisors. 1 is neither a prime nor a composite number.
  
  Input
  
  Each test contains multiple test cases.
  
  The first line contains one positive integer t (1 ≤ t ≤ 10^3), denoting the number of test cases. Description of the test cases follows.
  
  The first line of each test case contains one positive integer k (1 ≤ k ≤ 50) — the number of digits in the number.
  
  The second line of each test case contains a positive integer n, which doesn't contain zeros in decimal notation (10^{k-1} ≤ n < 10^{k}). It is guaranteed that it is always possible to remove less than k digits to make the number not prime.
  
  It is guaranteed that the sum of k over all test cases does not exceed 10^4.
  
  Output
  
  For every test case, print two numbers in two lines. In the first line print the number of digits, that you have left in the number. In the second line print the digits left after all delitions. 
  
  If there are multiple solutions, print any.
  
  Example
  
  Input
  
  
  7
  3
  237
  5
  44444
  3
  221
  2
  35
  3
  773
  1
  4
  30
  626221626221626221626221626221
  
  
  Output
  
  
  2
  27
  1
  4
  1
  1
  2
  35
  2
  77
  1
  4
  1
  6
  
  Note
  
  In the first test case, you can't delete 2 digits from the number 237, as all the numbers 2, 3, and 7 are prime. However, you can delete 1 digit, obtaining a number 27 = 3^3.
  
  In the second test case, you can delete all digits except one, as 4 = 2^2 is a composite number.
solution: import java.io.*;
  import java.util.*;
  import java.math.BigDecimal;
  import java.math.*;
  
  public class Main{
  	public static void main(String[] args) {
  	    
  	      TaskA solver = new TaskA();
  	     
  	      
  		     
  	      int t = in.nextInt();
  	      for (int i = 1; i <= t ; i++) {
  	          solver.solve(i, in, out);
  	      }
  	     
  	      
  //	      solver.solve(1, in, out);
  	      
  	      
  	      out.flush();
  	    out.close();
  	  }
  	
  	 static class TaskA {
  	      public void solve(int testNumber, InputReader in, PrintWriter out) {
  	    	 int n= in.nextInt();
  	    	 String str=in.next();
  //	    	 out.println(str);
  	    	 char[]c=str.toCharArray();
  	    	 for(int i=0;i<c.length;i++) {
  	    		 if(str.contains("1")) {
  	    			 out.println(1);out.println(1);
  	    			 return;
  	    		 }
  	    		 if(str.contains("4")) {
  	    			 out.println(1);out.println(4);
  	    			 return;
  	    		 }
  	    		 if(str.contains("6")) {
  	    			 out.println(1);out.println(6);
  	    			 return;
  	    		 }
  	    		 if(str.contains("8")) {
  	    			 out.println(1);out.println(8);
  	    			 return;
  	    		 }
  	    		 if(str.contains("9")) {
  	    			 out.println(1);out.println(9);
  	    			 return;
  	    		 }
  	    		 
  	    		 if(str.contains("2")) {
  	    			 int x= str.indexOf('2');
  	    			 if(str.substring(x+1).contains("5")) {
  	    				 out.println(2);
  	    				 println(25);
  	    				 return;
  	    			 }
  	    			 if(str.substring(x+1).contains("7")) {
  	    				  out.println(2);
  	    				 println(27);
  	    				 return;
  	    			 }
  	    			 if(str.substring(x+1).contains("2")) {
  	    				  out.println(2);  				 println(22);
  	    				 return;
  	    			 }
  	    			 
  	    		 }
  	    		 if(str.contains("3")) {
  	    			 int x= str.indexOf('3');
  	    			 if(str.substring(x+1).contains("3")) {
  	    				 out.println(2);  
  	    				 println(33);
  	    				 return;
  	    			 }
  	    			 if(str.substring(x+1).contains("2")) {
  	    				 out.println(2);  
  	    				 println(32);
  	    				 return;
  	    			 }
  	    			 if(str.substring(x+1).contains("5")) {
  	    				 out.println(2);  
  	    				 println(35);
  	    				 return;
  	    			 }
  	    			 
  	    		 }
  	    		 if(str.contains("5")) {
  	    			 int x= str.indexOf('5');
  	    			 if(str.substring(x+1).contains("2")) {
  	    				 out.println(2);  
  	    				 println(52);
  	    				 return;
  	    			 }
  	    			 if(str.substring(x+1).contains("5")) {
  	    				 out.println(2);  
  	    				 println(55);
  	    				 return;
  	    			 }
  	    			 if(str.substring(x+1).contains("7")) {
  	    				 out.println(2);  
  	    				 println(57);
  	    				 return;
  	    			 }
  	    			 
  	    		 }
  	    		 if(str.contains("7")) {
  	    			 int x= str.indexOf('7');
  	    			 if(str.substring(x+1).contains("2")) {
  	    				 out.println(2);  
  	    				 println(72);
  	    				 return;
  	    			 }
  	    			 if(str.substring(x+1).contains("5")) {
  	    				 out.println(2);  
  	    				 println(75);
  	    				 return;
  	    			 }
  	    			 if(str.substring(x+1).contains("7")) {
  	    				 out.println(2);  
  	    				 println(77);
  	    				 return;
  	    			 }
  	    			 
  	    		 }
  	    		 if(str.contains("5")) {
  	    			 int x= str.indexOf('5');
  	    			 if(str.substring(x+1).contains("3")) {
  	    				 int y= str.substring(x+1).indexOf('3');
  	    				 if(str.substring(y+1).contains("7")) {
  		    				 out.println(3);
  		    				 out.println(537);
  		    				 return;
  		    			 }
  	    			 }
  	    			 
  	    			 
  	    		 }
  	    		 
  	    		 if(str.contains("2")) {
  	    			 int x= str.indexOf('2');
  	    			 if(str.substring(x+1).contains("3")) {
  	    				 int y= str.substring(x+1).indexOf('3');
  	    			 if(str.substring(y+1).contains("7")) {
  	    				 out.println(3);
  	    				 out.println(237);
  	    				 return;
  	    			 }
  	    			 
  	    		 }
  	    			 
  	    	 }
  	    		 
  	    		 if(str.contains("7")) {
  	    			 int x= str.indexOf('7');
  	    			 if(str.substring(x+1).contains("3")) {
  	    				 int y= str.substring(x+1).indexOf('3');
  	    			 if(str.substring(y+1).contains("7")) {
  	    				 out.println(3);
  	    				 out.println(737);
  	    				 return;
  	    			 }
  	    			 
  	    		 }
  	    	 }
  	    		 else {
  	    			 out.println(4);
  	    			 out.println(3737);
  	    			 return;
  	    		 }
  	    	 }
  	      }
  	  }
  	 
  	 
  	 ////////////////////////////////////////////////////////
  	 static void sortF(Pair arr[], int n)
  	    {
  	        // Comparator to sort the pair according to second element
  	        Arrays.sort(arr, new Comparator<Pair>() {
  	            @Override public int compare(Pair p1, Pair p2)
  	            {
  	                return p1.first - p2.first;
  	            }
  	        });
  	    }
  	 static void sortS(Pair arr[], int n)
  	    {
  	        // Comparator to sort the pair according to second element
  	        Arrays.sort(arr, new Comparator<Pair>() {
  	            @Override public int compare(Pair p1, Pair p2)
  	            {
  	                return p1.second - p2.second;
  	            }
  	        });
  	    }
  	 
  	 static class Pair 
  	 {
  	   int first ;int second  ;
  	  
  	   public  Pair(int x, int y)
  	   {
  	       this.first = x ;this.second = y ;
  	   }
  	   
  	   @Override
  	  public boolean equals(Object obj)
  	  {
  	      if(obj == this)return true  ;
  	      
  	      if(obj == null)return false  ;
  	      
  	      if(this.getClass() != obj.getClass()) return false ;
  	      
  	      Pair other  = (Pair)(obj) ;
  	      
  	      if(this.first != other.first)return false  ;
  	      if(this.second != other.second)return false  ;
  	      
  	      return true  ;
  	      
  	  }
  	     
  	     @Override
  	     
  	     public int hashCode()
  	     {
  	         return this.first^this.second  ;
  	     }
  	       
  	 @Override
  	 	public String toString() {
  	 	
  	 	String ans = "" ;ans  += this.first ;	ans += " ";	ans += this.second ;
  	 	return ans  ;
  	 	}
  
  	 }
  	 //////////////////////////////////////////////////////////////////////////
  	
  	    
  	 
  	
  	 static int nD(long num) {
  		 String s=String.valueOf(num);
  		 return s.length();
  	 }
  	 
  	 
  	 static int CommonDigits(int x,int y) {
  		 String s=String.valueOf(x);
  		 String s2=String.valueOf(y);
  		 return 0;
  	 }
  	 
  	 
  	 
  	 static int lcs(String str1, String str2, int m, int n)
  	    {
  	        int L[][] = new int[m + 1][n + 1];
  	        int i, j;
  	 
  	        // Following steps build L[m+1][n+1] in
  	        // bottom up fashion. Note that L[i][j]
  	        // contains length of LCS of str1[0..i-1]
  	        // and str2[0..j-1]
  	        for (i = 0; i <= m; i++) {
  	            for (j = 0; j <= n; j++) {
  	                if (i == 0 || j == 0)
  	                    L[i][j] = 0;
  	 
  	                else if (str1.charAt(i - 1)
  	                         == str2.charAt(j - 1))
  	                    L[i][j] = L[i - 1][j - 1] + 1;
  	 
  	                else
  	                    L[i][j] = Math.max(L[i - 1][j],
  	                                       L[i][j - 1]);
  	            }
  	        }
  	 
  	        // L[m][n] contains length of LCS
  	        // for X[0..n-1] and Y[0..m-1]
  	        return L[m][n];
  	    }
  	 
  	 /////////////////////////////////
  	 boolean IsPowerOfTwo(int x)
  	 {
  	     return (x != 0) && ((x & (x - 1)) == 0);
  	 }
  	 ////////////////////////////////
  	 
  	 static long power(long a,long b,long m ) {
  		 long ans=1;
  		 while(b>0) {
  			 if(b%2==1) {
  				 ans=((ans%m)*(a%m))%m; b--;
  			 }
  			 else {
  				 a=(a*a)%m;b/=2;
  			 }
  			 
  		 }
  		 return ans%m;
  	 }
  	 ///////////////////////////////
  	 public static boolean repeatedSubString(String string) {
  		    return ((string + string).indexOf(string, 1) != string.length());
  		}
  	 static int search(char[]c,int start,int end,char x) {
  		 for(int i=start;i<end;i++) {
  			 if(c[i]==x) {return i;}
  		 }
  		 return -2;
  	 }
  	 ////////////////////////////////
  	 
  	 static int bs(int size,int[]arr) {
  		 int x = -1;
      	 for (int b = size/2; b >= 1; b /= 2) {
          	 while (!ok(arr));
          	 }
      	 int k = x+1;
      	 return k;
  	 }
  	 
  	 static boolean ok(int[]x) {
  		 return false;
  	 }
  	 
  	 static int gcd(int a, int b) {
  	        while (b != 0) {
  	            int t = b;
  	            b = a % b;
  	            a = t;
  	        }
  	        return a;
  	    }
  	
  	 
  	
  	 
  	 static long fac(long a)
  	 {
  	     if(a== 0L || a==1L)return 1L ;
  	     
  	     return a*fac(a-1L) ;
  	 }
  	 
  	 
  	 
  	 static ArrayList al() {
  		 ArrayList<Integer>a =new ArrayList<>();
  			return a;
  		}
  	 
  	static HashSet h() {
  			return new HashSet<Integer>();
  		}
  	static void debug(int[][]a) {
  		int n= a.length;
  		for(int i=1;i<=n;i++) {
  	  		for(int j=1;j<=n;j++) {
  	  			out.print(a[i][j]+" ");
  	  		}
  	  		out.print("\n");
  	  	}
  	}
  	static void debug(int[]a) {
  			out.println(Arrays.toString(a));
  		}
  	
  	static void debug(ArrayList<Integer>a) {
  				out.println(a.toString());
  		}
  	
  	static boolean[]seive(int n){
  		boolean[]b=new boolean[n+1];
  		 for (int i = 2; i <= n; i++)
  	            b[i] = true;
  		 
  		for(int i=2;i*i<=n;i++) {
  			if(b[i]) {
  				for(int j=i*i;j<=n;j+=i) {
  					b[j]=false;
  				}
  			}
  		}
  		return b;
  	}
  	
  	 static int longestIncreasingSubseq(int[]arr) {
  		  int[]sizes=new int[arr.length];
  		  Arrays.fill(sizes, 1);
  		  int max=1;
  		  for(int i=1;i<arr.length;i++) {
  			  for(int j=0;j<i;j++) {
  				  if(arr[j]<arr[i]) {
  					  sizes[i]=Math.max(sizes[i],sizes[j]+1);
  					  max=Math.max(max, sizes[i]);
  				  }
  			  }
  		  }
  		  return max;
  	 }
  	 
  	 public static ArrayList primeFactors(long n)
  	    {
  		    ArrayList<Long>h= new ArrayList<>();
  	        // Print the number of 2s that divide n
  	        if(n%2 ==0) {h.add(2L);}
  	 
  	        // n must be odd at this point.  So we can
  	        // skip one element (Note i = i +2)
  	        for (long i = 3; i <= Math.sqrt(n); i+= 2)
  	        {
  	            if(n%i==0) {h.add(i);}
  	        }
  	        if (n > 2)
  	            h.add(n);
  	        return h;
  	    }
  	 
  	 static boolean Divisors(long n){
  		 if(n%2==1) {
  			 return true;
  		 }
  	     for (long i=2; i<=Math.sqrt(n); i++){
  	            if (n%i==0 && i%2==1){
  	                   return true;
  	            } 
  	        }
  	     return false;
  	    }
  	
  	static InputStream inputStream = System.in;
      static OutputStream outputStream = System.out;
      static InputReader in = new InputReader(inputStream);
      static PrintWriter out = new PrintWriter(outputStream);
      
      public static void superSet(int[]a,ArrayList<String>al,int i,String s) {
      	if(i==a.length) {
      		al.add(s);
      		return;
      	}
      	superSet(a,al,i+1,s);
      	superSet(a,al,i+1,s+a[i]+" ");
      }
      
  	public static long[] makeArr() {
  		long size=in.nextInt();
  		long []arr=new long[(int)size];
  		for(int i=0;i<size;i++) {
  			arr[i]=in.nextInt();
  		}
  		return arr;
  	}
  	
  	public static long[] arr(int n) {
  		long []arr=new long[n+1];
  		for(int i=1;i<n+1;i++) {
  			arr[i]=in.nextLong();
  		}
  		return arr;
  	}
  	
    public static void sort(long arr[], int l, int r)
    {
        if (l < r)
        {
            // Find the middle point
            int m = (l+r)/2;
  
            // Sort first and second halves
            sort(arr, l, m);
            sort(arr , m+1, r);
  
            // Merge the sorted halves
            merge(arr, l, m, r);
        }
    }
  
    static void print(int c) {
  		 out.print(c);
  	 }
  	 static void println(int x) {
  		 out.println(x);
  	 }
  	 static void print(String s) {
  		 out.print(s);
  	 }
  	 static void println(String s) {
  		 out.println(s);
  	 }
  public static void merge(long arr[], int l, int m, int r)
    {
        // Find sizes of two subarrays to be merged
        int n1 = m - l + 1;
        int n2 = r - m;
  
        /* Create temp arrays */
        long L[] = new long[n1];
        long R[] = new long[n2];
  
        //Copy data to temp arrays
        for (int i=0; i<n1; ++i)
            L[i] = arr[l + i];
        for (int j=0; j<n2; ++j)
            R[j] = arr[m + 1+ j];
  
  
        /* Merge the temp arrays */
  
        // Initial indexes of first and second subarrays
        int i = 0, j = 0;
  
        // Initial index of merged subarry array
        int k = l;
        while (i < n1 && j < n2)
        {
            if (L[i] <= R[j])
            {
                arr[k] = L[i];
                i++;
            }
            else
            {
                arr[k] = R[j];
                j++;
            }
            k++;
        }
  
        /* Copy remaining elements of L[] if any */
        while (i < n1)
        {
            arr[k] = L[i];
            i++;
            k++;
        }
  
        /* Copy remaining elements of R[] if any */
        while (j < n2)
        {
            arr[k] = R[j];
            j++;
            k++;
        }
    }
  
  public static void reverse(int[] array)
  {
      int n = array.length;
      for (int i = 0; i < n / 2; i++) {
          int temp = array[i];
          array[i] = array[n - i - 1];
          array[n - i - 1] = temp;
      }
  }
  
    public static long nCr(int n,int k)
    {
        long ans=1L;
        k=k>n-k?n-k:k;
       
        for( int j=1;j<=k;j++,n--)
        {
            if(n%j==0)
            {
                ans*=n/j;
            }else
            if(ans%j==0)
            {
                ans=ans/j*n;
            }else
            {
                ans=(ans*n)/j;
            }
        }
        return ans;
    }
  
    static int searchMax(int index,long[]inp) {
  	  while(index+1<inp.length &&inp[index+1]>inp[index]) {
  		  index+=1;
  	  }
  	  return index;
    }
    static int searchMin(int index,long[]inp) {
  	  while(index+1<inp.length &&inp[index+1]<inp[index]) {
  		  index+=1;
  	  }
  	  return index;
    }
    public class ListNode {
  	       int val;
  	       ListNode next;
  	       ListNode() {}
  	       ListNode(int val) { this.val = val; }
  	       ListNode(int val, ListNode next) { this.val = val; this.next = next; }
  	   }
    
    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;
  
        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }
  
        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }
  
        public int nextInt() {
            return Integer.parseInt(next());
        }
        public long nextLong() {
      	  return Long.parseLong(next());
        }
    }
  }