After playing Neo in the legendary "Matrix" trilogy, Keanu Reeves started doubting himself: maybe we really live in virtual reality? To find if this is true, he needs to solve the following problem.

Let's call a string consisting of only zeroes and ones good if it contains different numbers of zeroes and ones. For example, 1, 101, 0000 are good, while 01, 1001, and 111000 are not good.

We are given a string s of length n consisting of only zeroes and ones. We need to cut s into minimal possible number of substrings s_1, s_2, …, s_k such that all of them are good. More formally, we have to find minimal by number of strings sequence of good strings s_1, s_2, …, s_k such that their concatenation (joining) equals s, i.e. s_1 + s_2 + ... + s_k = s.

For example, cuttings 110010 into 110 and 010 or into 11 and 0010 are valid, as 110, 010, 11, 0010 are all good, and we can't cut 110010 to the smaller number of substrings as 110010 isn't good itself. At the same time, cutting of 110010 into 1100 and 10 isn't valid as both strings aren't good. Also, cutting of 110010 into 1, 1, 0010 isn't valid, as it isn't minimal, even though all 3 strings are good.

Can you help Keanu? We can show that the solution always exists. If there are multiple optimal answers, print any.

Input

The first line of the input contains a single integer n (1≤ n ≤ 100) — the length of the string s.

The second line contains the string s of length n consisting only from zeros and ones.

Output

In the first line, output a single integer k (1≤ k) — a minimal number of strings you have cut s into.

In the second line, output k strings s_1, s_2, …, s_k separated with spaces. The length of each string has to be positive. Their concatenation has to be equal to s and all of them have to be good.

If there are multiple answers, print any.

Examples

Input


1
1


Output


1
1

Input


2
10


Output


2
1 0

Input


6
100011


Output


2
100 011

Note

In the first example, the string 1 wasn't cut at all. As it is good, the condition is satisfied.

In the second example, 1 and 0 both are good. As 10 isn't good, the answer is indeed minimal.

In the third example, 100 and 011 both are good. As 100011 isn't good, the answer is indeed minimal.
72
111101100111001110000000100010100000011011100110001010111010101011111100
 3
101
 18
101111001111000110
 7
1111000
 3
010
 12
101010100101
 1
0
 4
1010
 6
101100
 100
0010110000001111110111101011100111101000110011011100100011110001101110000001000010100001011011110001
 2
01
 8
11000011
 15
110001101000101
 36
111100110011010001010010100011001101
 8
10100011
 3
111
 4
0101
 4
1100
 6
010011
 3
100
 3
000
 8
10010101
 100
0110110011011111001110000110010010000111111001100001011101101000001011001101100111011111100111101110
 80
01110111110010110111011110101000110110000111000100111000000101001011111000110011
 10
1100010011
 20
10010000010111010111
 44
10010000111011010000111011111010010100001101
 4
1000
 8
11001100
 6
100011
 2
00
 45
101001101111010010111100000111111010111001001
 10
1101001100
 2
11

2
1 11101100111001110000000100010100000011011100110001010111010101011111100
 1
101
 1
101111001111000110
 1
1111000
 1
010
 2
1 01010100101
 1
0
 2
1 010
 2
1 01100
 2
0 010110000001111110111101011100111101000110011011100100011110001101110000001000010100001011011110001
 2
0 1
 2
1 1000011
 1
110001101000101
 2
1 11100110011010001010010100011001101
 2
1 0100011
 1
111
 2
0 101
 2
1 100
 2
0 10011
 1
100
 1
000
 2
1 0010101
 1
0110110011011111001110000110010010000111111001100001011101101000001011001101100111011111100111101110
 1
01110111110010110111011110101000110110000111000100111000000101001011111000110011
 2
1 100010011
 2
1 0010000010111010111
 2
1 0010000111011010000111011111010010100001101
 1
1000
 2
1 1001100
 2
1 00011
 1
00
 1
101001101111010010111100000111111010111001001
 2
1 101001100
 1
11

/* package codechef; // don't place package name! */

import java.util.*;
import java.lang.*;
import java.io.*;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;
import java.util.StringTokenizer;

/* Name of the class has to be "Main" only if the class is public. */


public class Codechef
{
    static int mod=1000000007;
    static FastReader sc=new FastReader();
    
    
    //input (int)
    static int i() 
    {
    	 return sc.nextInt();
    }
    
    //input (string)
     static String s() {
    	 return sc.next();
    }
    
    //input (long)
    static long l() 
    {
    	 return sc.nextLong();
    }  
    
    //printing ln int
    static void println(int a)
    {
        System.out.println(a);
    }
    
    //printing int
    static void print(int a)
    {
        System.out.print(a+" ");
    }
    
    //printing ln long
    static void println(long a)
    {
        System.out.println(a);
    }
    
    //printing long
    static void print(long a)
    {
        System.out.print(a+" ");
    }
    
    //printing string ln
    static void println(String a)
    {
        System.out.println(a);
    }
    
    //printing String
    static void print(String a)
    {
        System.out.print(a+" ");
    }
    
    //printing array elements(int )
    static void print(int A[]) 
    {
    	for(int i=0;i<A.length;i++)
    		System.out.print(A[i]+" ");
    	System.out.println();
    }
    
     //printing array elements(long)
    static void print(long A[]) 
    {
    	for(int i=0;i<A.length;i++)
    		System.out.print(A[i]+" ");
    	System.out.println();
    }
    
    //printing array elements(String)
    static void print(String A[]) 
    {
    	for(int i=0;i<A.length;i++)
    		System.out.print(A[i]+" ");
    	System.out.println();
    }
    
    
    //taking input in an array of size n(int)
    static int[] input(int n) 
    {
	int A[]=new int[n];
	   for(int i=0;i<n;i++) 
		   A[i]=sc.nextInt();
	   return A;
    }
    
     // taking input in an array of size n(long)
    static long[] inputL(int n) 
    {
	    long A[]=new long[n];
	    for(int i=0;i<n;i++) 
		   A[i]=sc.nextLong();
	    return A;
    }
    
    
    
 
    
    // taking input in array of size n(String)
    static String[] inputS(int n) 
    {
	    String A[]=new String[n];
	    for(int i=0;i<n;i++)
		   A[i]=sc.next();
	   
	    return A;
    }
    
    //array elements to hashmap
    static HashMap<Integer,Integer> hash(int A[])
    {
	    HashMap<Integer,Integer> map=new HashMap<Integer, Integer>();
	    for(int i : A) 
	    {
		    if(map.containsKey(i)) 
			    map.put(i, map.get(i)+1);
		    else
			    map.put(i, 1);
	    }
	    return map;
  }
    
    
    // max(int)
    static int max(int A[]) 
    {
    	int max=Integer.MIN_VALUE;
    	for(int i=0;i<A.length;i++)
    		max=Math.max(max, A[i]);
    	return max;
    }
    
    // max(long)
    static long max(long A[]) 
    {
    	long max=Long.MIN_VALUE;
    	for(int i=0;i<A.length;i++)
    		max=Math.max(max, A[i]);
    	return max;
    }
    
    //min(long)
    static long min(long A[])
    {
    	long min=Long.MAX_VALUE;
    	for(int i=0;i<A.length;i++)
    		min=Math.min(min, A[i]);
    	return min;
    }
    
    // min(int)
    static int min(int A[])
    {
    	int min=Integer.MAX_VALUE;
    	for(int i=0;i<A.length;i++)
    		min=Math.min(min, A[i]);
    	return min;
    }
    
    // sum of (int) elements of an array
    static long sum(int A[]) 
    {
    	long sum=0;
    	for(int i : A) 
    		sum+=i;
    	return sum;
    }
    
    // sum of (long) elements of an array
    static long sum(long A[]) 
    {
    	long sum=0;
    	for(long i : A)
    		sum+=i;
    	return sum;
    }
    
    // copying array elements to another array
    static int[] copy(int A[]) 
    {
    	int B[]=new int[A.length];
    	for(int i=0;i<A.length;i++) 
    		B[i]=A[i];
    	return B;
    }
    
    // reverse an array(long)
    static void reverse(long A[]) 
    {
    	int n=A.length;
    	long B[]=new long[n];
    	for(int i=0;i<n;i++)
    		B[i]=A[n-i-1];
    	for(int i=0;i<n;i++)
    		A[i]=B[i];
    	
    }
    
    // reverse an array(int)
    static void reverse(int A[])
    {
    	int n=A.length;
    	int B[]=new int[n];
    	for(int i=0;i<n;i++) 
    		B[i]=A[n-i-1];
    	for(int i=0;i<n;i++)
    		A[i]=B[i];
    	
    }
    
    

    // prefix sum(long)
    static long [] prefix(long A[]) 
    {
    	long p[]=new long[A.length];
    	p[0]=A[0];
    	for(int i=1;i<A.length;i++)
    		p[i]=p[i-1]+A[i];
    	return p;
    }
    
    // prefix sum(int)
    static long [] prefix(int A[]) 
    {
    	long p[]=new long[A.length];
    	p[0]=A[0];
    	for(int i=1;i<A.length;i++)
    		p[i]=p[i-1]+A[i];
    	return p;
    }

    //suffix sum(long)
    static long [] suffix(long A[]) 
    {
    	long p[]=new long[A.length];
    	p[A.length-1]=A[A.length-1];
    	for(int i=A.length-2;i>=0;i--)
    		p[i]=p[i+1]+A[i];
    	return p;
    }

    //suffix sum(int)
    static long [] suffix(int A[]) 
    {
    	long p[]=new long[A.length];
    	p[A.length-1]=A[A.length-1];
    	for(int i=A.length-2;i>=0;i--)
    		p[i]=p[i+1]+A[i];
    	return p;
    }
    
    //checking if a number is a prime
    static boolean prime(int n) 
    { 
        if (n <= 1) 
            return false; 
        if (n <= 3) 
            return true; 
        if (n % 2 == 0 || n % 3 == 0) 
            return false; 
        double sq=Math.sqrt(n);
  
        for (int i = 5; i <= sq; i = i + 6) 
            if (n % i == 0 || n % (i + 2) == 0) 
                return false; 
        return true; 
    } 
    
    //binary search
    public static int binarysearch(int[] nums,int k)
    {
        int low=0;
        int high=nums.length-1;
        while(low<=high)
        {
            int mid=low+(high-low)/2;
            if(k==nums[mid])
                return mid;
            else if(k>nums[mid])
                low=mid+1;
            else
                high=mid-1;
        }
        return -1;
    }
    
    public static int bs(int[] nums,int k)
    {
        int low=0;
        int high=nums.length-1;
        while(low<=high)
        {
            int mid=low+(high-low)/2;
            if(k==nums[mid])
                return mid;
            else if(k>nums[mid])
                low=mid+1;
            else
                high=mid-1;
        }
        return low;
    }

   



   
   
    
    
    
   
    static class FastReader {
        BufferedReader br;
        StringTokenizer st;
 
        public FastReader()
        {
            br = new BufferedReader(
                new InputStreamReader(System.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());
        }
 
        String nextLine()
        {
            String str = "";
            try {
                str = br.readLine();
            }
            catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
    }
    
   
	public static void main (String[] args) throws java.lang.Exception
	{
	    
	    
	        int n=i();
	        String a=s();
	        int count0=0,count1=0;
	        for(int i=0;i<a.length();i++)
	        {
	            if(a.charAt(i)=='0')
	                count0++;
	            else 
	                count1++;
	        }

	        if(count0!=count1)
	            println(a);
	        else
	        {
	            System.out.println(a.charAt(0)+" "+a.substring(1,a.length()-1));
	        }
	    
	    
	    
	
	}
	

}

