import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Scanner;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author grolegor
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        Scanner in = new Scanner(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskA solver = new TaskA();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskA {
        public void solve(int testNumber, Scanner in, PrintWriter out) {
            int n = in.nextInt();
            String s = in.next();
            if (n % 2 == 1) {
                out.println(1);
                out.println(s);
            } else {
                int ones = 0;
                int zeros = 0;
                for (int i = 0; i < n; i++) {
                    if (s.charAt(i) == '1') ones++;
                    if (s.charAt(i) == '0') zeros++;
                }
                if (ones != zeros) {
                    out.println(1);
                    out.println(s);
                } else {
                    out.println(2);
                    out.println(s.substring(0, 1) + " " + s.substring(1));
                }
            }
        }

    }
}

import java.util.Scanner;
public class AL{
    static int count(char a,String list ){
        int result=0;
        for (int i=0;i<list.length();i++){
            if (list.charAt(i)==a){
                result=result+1;
            }
        }
        return result;
    }
    public static void main(String args[]){
        Scanner STDIN=new Scanner(System.in);
        int a=STDIN.nextInt();
        int result=0;
        String list= STDIN.next();
        if (count('1',list) != count('0',list)){
            System.out.println(1);
            result=1;
        }
        else if (a>1){
            System.out.println(2);}
        else{
            result=1;
            System.out.println(1);
        }
        if (result!=1){

            System.out.print(list.charAt(0));
            System.out.print(" ");
            for (int i=1;i<list.length();i++){
                System.out.print(list.charAt(i));}}
        else{
            System.out.println(list);
        }
    }
}

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

public class cheap {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n=sc.nextInt();
       String s=sc.next();
       int count0=0;
       int count1=0;
    //   int start=0;
      // int end=n-1;
        for(int i=0;i<s.length();i++)
        {
            if(s.charAt(i)=='1')
            {
                count1++;
            }else{
                count0++;
            }
        }
        if(count1!=count0)
        {
           System.out.println("1");
           System.out.println(s);
        }else{
           // start=0;
            //end=n-1;
            //int mid=start+(end-start)/2;
            System.out.println("2");
            System.out.println(s.substring(0,n-1)+"");
            System.out.println(s.charAt(n-1)+"");
          //  System.out.println(s.charAt(n-1));
        }
    }
}

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

import static java.lang.Math.*;

public class Main implements Runnable {
    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private SpaceCharFilter filter;
        private BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public int read() {
            if (numChars==-1)
                throw new InputMismatchException();

            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                }
                catch (IOException e) {
                    throw new InputMismatchException();
                }

                if(numChars <= 0)
                    return -1;
            }
            return buf[curChar++];
        }

        public String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            }
            catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
        public int nextInt() {
            int c = read();

            while(isSpaceChar(c))
                c = read();

            int sgn = 1;

            if (c == '-') {
                sgn = -1;
                c = read();
            }

            int res = 0;
            do {
                if(c<'0'||c>'9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            }
            while (!isSpaceChar(c));

            return res * sgn;
        }

        public long nextLong() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            long res = 0;

            do {
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            }
            while (!isSpaceChar(c));
                return res * sgn;
        }

        public double nextDouble() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            double res = 0;
            while (!isSpaceChar(c) && c != '.') {
                if (c == 'e' || c == 'E')
                    return res * Math.pow(10, nextInt());
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            }
            if (c == '.') {
                c = read();
                double m = 1;
                while (!isSpaceChar(c)) {
                    if (c == 'e' || c == 'E')
                        return res * Math.pow(10, nextInt());
                    if (c < '0' || c > '9')
                        throw new InputMismatchException();
                    m /= 10;
                    res += (c - '0') * m;
                    c = read();
                }
            }
            return res * sgn;
        }

        public String readString() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            StringBuilder res = new StringBuilder();
            do {
                res.appendCodePoint(c);
                c = read();
            }
            while (!isSpaceChar(c));

            return res.toString();
        }

        public boolean isSpaceChar(int c) {
            if (filter != null)
                return filter.isSpaceChar(c);
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public String next() {
            return readString();
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);
        }
    }
    public static void main(String args[]) throws Exception {
        new Thread(null, new Main(),"Main",1<<26).start();
    }
    public void run() {
        InputReader sc = new InputReader(System.in);
        PrintWriter w = new PrintWriter(System.out);

                  int n=sc.nextInt();
                  String s=sc.next();
                  int count=0,i=0;
                  for(i=0;i<s.length();i++)
                  {
                                if(s.charAt(i)=='1')
                                {
                                                  count++;
                                }
                                else
                                {
                                                  count--;
                                }
                  }

                                    if(count!=0)
                                    {
                                                      w.print(1+"\n"+s);
                                    }
                                    else
                                    {
                                                      w.print(2+"\n");
                                                      for(i=0;i<n-1;i++)
                                                      {
                                                                        w.print(s.charAt(i));
                                                      }
                                                      w.print(" "+s.charAt(i));
                                    }

        w.close();
    }

}

import java.io.*;
public class keanu
{
 public static void main(String args[])throws IOException
 {
  InputStreamReader read=new InputStreamReader(System.in);
  BufferedReader in=new BufferedReader(read);
  int i,n,no,nz;
  no=nz=0;
  char p;
  String a;
  n=Integer.parseInt(in.readLine());
  a=in.readLine();
  for(i=0;i<n;i++)
  {
   p=a.charAt(i);
   if(p=='1')
   no+=1;
   else
   nz+=1;
  }
  if(no!=nz)
  {
   System.out.println("1");
   System.out.print(a);
  }
  else
  {
   System.out.println("2");
   System.out.print(a.substring(0,1)+" "+a.substring(1));
  }
 }
}

import java.io.*;
import java.util.Arrays;
import java.util.Comparator;
import java.util.StringTokenizer;

public class problem {

    public static void main(String[] args) throws IOException {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter writer = new PrintWriter(new OutputStreamWriter(System.out));

        int n = Integer.parseInt(reader.readLine());

        char[] string = reader.readLine().toCharArray();

        int onecounter = 0;
        int zerocounter = 0;

        for (int i = 0; i < string.length; i++) {
            if (string[i] == '1') {
                onecounter++;
            } else {
                zerocounter++;
            }
        }

        if (onecounter == zerocounter) {
            writer.println(2);
            writer.print(string[0]);
            writer.print(" ");
            for (int i = 1; i < string.length; i++) {
                writer.print(string[i]);
            }
        } else {
            writer.println(1);
            for (int i = 0; i < string.length; i++) {
                writer.print(string[i]);
            }
        }

        writer.close();

    }

}

import java.util.*;

/**
 *
 * @author Mahmoud
 */
public class Code {

    /**
     *
     * @param args the command line arguments
     */

    public static void main(String[] args) {

        Scanner sc =new Scanner(System.in);

        int x =sc.nextInt();
        String y =sc.next();

        int ze=0,one=0;

        for(int i =0 ;i< y.length(); i++)
        {
         if(y.charAt(i) == '0') ze++;
         else
             one++;

        }

        System.out.println((ze == one)? "2\n"+y.substring(0, y.length()-1)+" "+y.charAt(y.length()-1):"1\n"+y);
}
}

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

public class Solution7 {
    public static boolean isGood(String str) {
        int zeros = 0, ones = 0;
        for(int i=0; i<str.length(); i++) {
            if(str.charAt(i) == '0')
                zeros++;
            else
                 ones++;
        }

        return (zeros != ones);
    }

    public static void main(String args[]) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        //int t = Integer.parseInt(br.readLine().trim());

       // while(t > 0) {
            int n = Integer.parseInt(br.readLine().trim());
            String str = br.readLine().trim();
            if(isGood(str)) {
                System.out.println("1");
                System.out.println(str);
            } else {
                System.out.println("2");
                System.out.println(str.substring(0,1)+" "+str.substring(1));
            }
            //String inp[] = br.readLine().trim().split("\\s");
            //int arr[] = new int[n];

            //System.out.println();
            //t--;
       // }
    }
}

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

public class Main {
    public static void main(String[] args) throws IOException {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        InputReader.OutputWriter out = new InputReader.OutputWriter(outputStream);

        int n = in.nextInt();
        String s = in.next();
        int zeroes = 0;
        int ones = 0;
        for (int i = 0; i < s.length(); i++) {
            if(s.charAt(i) == '0') zeroes++;
            else ones++;
        }
        if(n == 1) {
            out.println(1);
            out.println(s);
        }
        else {
            if(ones == zeroes) {
                out.println(2);
                out.println(s.substring(0,1) + " " + s.substring(1));
            }
            else {
                out.println(1);
                out.println(s);
            }
        }

        out.flush();
    }
}

class InputReader extends BufferedReader {
    StringTokenizer tokenizer;

    public InputReader(InputStream inputStream) {
        super(new InputStreamReader(inputStream), 32768);
    }

    public InputReader(String filename) {
        super(new InputStreamReader(Thread.currentThread().getContextClassLoader().getResourceAsStream(filename)));
    }

    public String next() {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
            try {
                tokenizer = new StringTokenizer(readLine());
            } catch (IOException e) {
                throw new RuntimeException();
            }
        }
        return tokenizer.nextToken();
    }

    public Integer nextInt() {
        return Integer.valueOf(next());
    }
    public Long nextLong() {return  Long.valueOf(next());}

    static class OutputWriter extends PrintWriter {
        public OutputWriter(OutputStream outputStream) {
            super(outputStream);
        }

        public OutputWriter(Writer writer) {
            super(writer);
        }

        public OutputWriter(String filename) throws FileNotFoundException {
            super(filename);
        }

        public void close() {
            super.close();
        }
    }
}

//package hello;
import java.util.*;
public class keanuReeves
{
	public static void main(String args[])
	{
		Scanner scan = new Scanner(System.in);
		int n = scan.nextInt();

		String text = "";
		while(text.length()==0)
		text=scan.nextLine();
		int cnt=0;
		for(int i=0;i<n;i++)
		{
			if(text.charAt(i)=='1')cnt++;
		}
		if(2*cnt==n)
		{
			System.out.println(2);
			System.out.println(text.charAt(0)+" " +text.substring(1));
		}
		else
		{
			System.out.println(1);
			System.out.println(text);
		}
	}
}

import java.util.*;

public class TV3 {

	public static void main(String[]args) {

		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();

		String s = sc.next();

		int count0 = 0;
		int count1 = 0;

		for(int i = 0 ; i< n ; i++) {

			if(s.charAt(i)== '0') {

				count0 = count0 + 1;
			}
			else {
				count1 = count1 + 1;
			}
		}
		if(count0 != count1) {

			System.out.println("1");
			System.out.println(s);
		}
		else
		{
			System.out.println("2");
			System.out.print(s.charAt(0)+ " " );

			for(int i = 1 ; i<n; i++) {

				System.out.print(s.charAt(i));

			}
		}

	}
}

import java.util.*;import java.io.*;import java.math.*;

public class Main
{

    public static void process()throws IOException
    {
        int n=ni();
        char arr[]=(" "+nln()).toCharArray();
        int z=0,o=0;
        for(int i=1;i<=n;i++) if(arr[i]=='0') z++; else o++;

        if(z!=o){
            pn(1);
            for(int i=1;i<=n;i++) p(arr[i]);
            return;
        }

        pn(2);
        p(arr[1]+" ");
        for(int  i=2;i<=n;i++) p(arr[i]);
        pn("");
    }

    static AnotherReader sc;
    static PrintWriter out;
    public static void main(String[]args)throws IOException
    {
        out = new PrintWriter(System.out);
        sc=new AnotherReader();
        boolean oj = true;

        oj = System.getProperty("ONLINE_JUDGE") != null;
        if(!oj) sc=new AnotherReader(100);

        long s = System.currentTimeMillis();
        int t=1;
        while(t-->0)
            process();
        out.flush();
        if(!oj)
            System.out.println(System.currentTimeMillis()-s+"ms");
        System.out.close();
    }

    static void pn(Object o){out.println(o);}
    static void p(Object o){out.print(o);}
    static void pni(Object o){out.println(o);System.out.flush();}
    static int ni()throws IOException{return sc.nextInt();}
    static long nl()throws IOException{return sc.nextLong();}
    static double nd()throws IOException{return sc.nextDouble();}
    static String nln()throws IOException{return sc.nextLine();}
    static long gcd(long a, long b)throws IOException{return (b==0)?a:gcd(b,a%b);}
    static int gcd(int a, int b)throws IOException{return (b==0)?a:gcd(b,a%b);}
    static int bit(long n)throws IOException{return (n==0)?0:(1+bit(n&(n-1)));}
    static boolean multipleTC=false;

/////////////////////////////////////////////////////////////////////////////////////////////////////////

    static class AnotherReader{BufferedReader br; StringTokenizer st;
    AnotherReader()throws FileNotFoundException{
    br=new BufferedReader(new InputStreamReader(System.in));}
    AnotherReader(int a)throws FileNotFoundException{
    br = new BufferedReader(new FileReader("input.txt"));}
    String next()throws IOException{
    while (st == null || !st.hasMoreElements()) {try{
    st = new StringTokenizer(br.readLine());}
    catch (IOException  e){ e.printStackTrace(); }}
    return st.nextToken(); } int nextInt() throws IOException{
    return Integer.parseInt(next());}
    long nextLong() throws IOException
    {return Long.parseLong(next());}
    double nextDouble()throws IOException { return Double.parseDouble(next()); }
    String nextLine() throws IOException{ String str = ""; try{
    str = br.readLine();} catch (IOException e){
    e.printStackTrace();} return str;}}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class A1189 {
		public static void main(String[] args) {
	        InputStream inputStream = System.in;
	        OutputStream outputStream = System.out;
	        InputReader in = new InputReader(inputStream);
	        PrintWriter out = new PrintWriter(outputStream);
	        TaskA solver = new TaskA();
//	        int t = in.nextInt();
//	        for(int i=0;i<t;i++)
	        solver.solve(in, out);
	        out.close();
	    }

	    static class TaskA {
	        public void solve(InputReader in, PrintWriter out) {
	        	int n = in.nextInt();
	        	String s = in.next();
	        	int zc=0,oc=0;
	        	for(int i=0;i<n;i++) {
	        		if(s.charAt(i)=='0') zc++;
	        		else oc++;
	        	}
	        	if(zc!=oc) {
	        		System.out.println("1");
	        		System.out.println(s);
	        	}
	        	else {
	        		System.out.println("2");
	        		System.out.println(s.substring(0,n-1)+" "+s.charAt(n-1));
	        	}

	        }
	    }

	    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 long nextLong() {
	            return Long.parseLong(next());
	        }
	        public int nextInt() {
	        	return Integer.parseInt(next());
	        }

	    }
}

import java.util.Scanner;

/**
 *
 * @author DELL
 */
public class codeforces {
    public static void main(String[] args) {
           Scanner sc=new Scanner(System.in);
           int n=sc.nextInt();
           String s=sc.next();
           int bal=0;
           for(int i=0;i<n;i++)
           {
               if(s.charAt(i)=='0')
                   bal+=1;
               else
                   bal-=1;
           }
           if(bal!=0)
           {
               System.out.println("1");
               System.out.println(s);
           }
           else
           {
               System.out.println("2");
               System.out.println(s.substring(0,n-1)+" "+s.substring(n-1,n));
           }
}
}

import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;
import java.lang.*;
public class Main{
	static long mod = 1000000007;
	static InputReader in = new InputReader(System.in);
	static PrintWriter pw = new PrintWriter(System.out);
	public static void main(String[] args) throws Exception {
		 //int t=in.readInt();
		 //while(t-->0){
			int n=in.readInt();
			String s=in.readString();
			ArrayList<String> al=new ArrayList<>();
			int count0=0,count1=0;
			for(int i=0;i<n;i++) {
				if(s.charAt(i)=='0')
					count0++;
				else
					count1++;
			}
			if(count0==count1) {
				al.add(s.substring(0,n-1));
				al.add(s.substring(n-1, n));
				System.out.println(2);
				System.out.println(al.get(0)+" "+al.get(1));
			}
			else {
				System.out.println(1);
				System.out.println(s);
			}

		 //}
	}
	static String  reverse(String s1) {
		String s2="";
		for(int i=s1.length()-1;i>=0;i--) {
			s2+=s1.charAt(i);
		}
		return s2;
	}
	static boolean isVowel(char c) {
		if(c=='a'||c=='e'||c=='i'||c=='o'||c=='u')
			return true;
		return false;
	}
	static String removeChar(String s,int a,int b) {
		return s.substring(0,a)+s.substring(b,s.length());
	}
	static int[]  nextIntArray(int n){
		int[] arr= new int[n];
		int i=0;
		while(i<n){
			arr[i++]=in.readInt();
		}
		return arr;
	}
	static long[] nextLongArray(int n){
		long[]arr= new long[n];
		int i=0;
		while(i<n){
			arr[i++]=in.readLong();
		}
		return arr;
	}
	static int[]  nextIntArray1(int n) {
		int[] arr= new int[n+1];
		int i=1;
		while(i<=n){
			arr[i++]=in.readInt();
		}
		return arr;
	}
	static long[] nextLongArray1(int n){
		long[]arr= new long[n+1];
		int i=1;
		while(i<=n) {
			arr[i++]=in.readLong();
		}
		return arr;
	}
	static long gcd(long x, long y) {
		if (x % y == 0)
			return y;
		else
			return gcd(y, x % y);
	}
	static long pow(long n, long m) {
		if(m==0)
			return 1;
		else if(m==1)
			return n;
		else {
			long r=pow(n,m/2);
			if(m%2==0)
				return r*r;
			else
				return r*r*n;
		}
	}
	static long max(long a,long b,long c) {
		return Math.max(Math.max(a, b),c);
	}
	static long min(long a,long b,long c) {
		return Math.min(Math.min(a, b), c);
	}
	static class Pair implements Comparable<Pair> {
		int a, b;
		Pair(int a, int b) {
			this.a = a;
			this.b = b;
		}
		public int compareTo(Pair o) {
			if (this.a != o.a)
				return Integer.compare(this.a, o.a);
			else
				return Integer.compare(this.b, o.b);
			// return 0;
		}
		public boolean equals(Object o) {
			if (o instanceof Pair) {
				Pair p = (Pair) o;
				return p.a == a && p.b == b;
			}
			return false;
		}
		public int hashCode() {
			return new Integer(a).hashCode() * 31 + new Integer(b).hashCode();
		}
	}
	static class InputReader {
		private InputStream stream;
		private byte[] buf = new byte[1024];
		private int curChar;
		private int numChars;
		private SpaceCharFilter filter;
		public InputReader(InputStream stream) {
			this.stream = stream;
		}
		public int read() {
			if (numChars == -1)
				throw new InputMismatchException();
			if (curChar >= numChars) {
				curChar = 0;
				try {
					numChars = stream.read(buf);
				} catch (IOException e) {
					throw new InputMismatchException();
				}
				if (numChars <= 0)
					return -1;
			}
			return buf[curChar++];
		}
		public int readInt() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = read();
			}
			int res = 0;
			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			} while (!isSpaceChar(c));
			return res * sgn;
		}
		public String readString() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			StringBuilder res = new StringBuilder();
			do {
				res.appendCodePoint(c);
				c = read();
			} while (!isSpaceChar(c));
			return res.toString();
		}
		public double readDouble() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = read();
			}
			double res = 0;
			while (!isSpaceChar(c) && c != '.') {
				if (c == 'e' || c == 'E')
					return res * Math.pow(10, readInt());
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			}
			if (c == '.') {
				c = read();
				double m = 1;
				while (!isSpaceChar(c)) {
					if (c == 'e' || c == 'E')
						return res * Math.pow(10, readInt());
					if (c < '0' || c > '9')
						throw new InputMismatchException();
					m /= 10;
					res += (c - '0') * m;
					c = read();
				}
			}
			return res * sgn;
		}
		public long readLong() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = read();
			}
			long res = 0;
			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			} while (!isSpaceChar(c));
			return res * sgn;
		}
		public boolean isSpaceChar(int c) {
			if (filter != null)
				return filter.isSpaceChar(c);
			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
		}
		public interface SpaceCharFilter {
			public boolean isSpaceChar(int ch);
		}
	}
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Scanner;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author Bisoye
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        Scanner in = new Scanner(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        AKeanuReeves solver = new AKeanuReeves();
        solver.solve(1, in, out);
        out.close();
    }

    static class AKeanuReeves {
        public void solve(int testNumber, Scanner in, PrintWriter out) {
            int n = Integer.parseInt(in.next());
            String s = in.next();

            int count = 0;
            for (char ch : s.toCharArray()) {
                if (ch == '0') count--;
                else count++;
            }
            if (count != 0) {
                out.println(1);
                out.println(s);
            } else {
                out.println(2);
                out.println(s.substring(0, s.length() - 1) + " " + s.charAt(s.length() - 1));
            }
        }

    }
}

/******************************************************************************

                            Online Java Compiler.
                Code, Compile, Run and Debug java program online.
Write your code in this editor and press "Run" button to execute it.

*******************************************************************************/
import java.util.*;
public class Main
{
	public static void main(String[] args) {
		long n,zeros=0,ones=0,z1=0,o1=0,i;
		Scanner s=new Scanner(System.in);

		String s1;
		n=s.nextLong();

		  s1=s.next();
		for(i=0;i<n;i++)
		{
		    if(s1.charAt((int)i)=='0')
		    zeros++;
		    else
		    ones++;
		}
		if(zeros!=ones)
		{
		    System.out.println(1);
		    System.out.println(s1);
		}
		else
		{

		   StringBuffer sb=new StringBuffer(s1);
		       if(sb.charAt((int)n-1)=='0')
		       {
		       zeros--;
		       z1=1;
		       }
		       else
		       ones--;
		       sb.delete((int)n-1,(int)n);
		   System.out.println(2);
		   System.out.print(sb);
		   if(z1==1)
		   System.out.print(" "+'0');
		   else
		   System.out.print(" "+'1');
		}
	}
}

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

public class Main {
	static final int MOD_PRIME = 1000000007;

	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		Task solver = new Task();

		int i = 0;
		int t = 1;
		//t = in.nextInt();
		for (; i < t; i++)
			solver.solve(i, in, out);

		out.close();
	}

	static class Task {
		public void solve(int testNumber, InputReader in, PrintWriter out) {
			int n = in.nextInt();
			String s = in.next();
			int zc = 0;
			for(int i = 0; i < s.length(); i++) {
				if(s.charAt(i) == '0') zc++;
			}

			int k = 0;
			if(zc*2 == s.length()) k++;

			out.println(k + 1);
			if(k == 0) {
				out.println(s);
			}else {
				for(int i = 0; i < s.length() - 1; i++) {
					out.print(s.charAt(i));
				}
				out.print(" " + s.charAt(s.length() - 1));
			}

		}
	}

// template code

	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());
		}

		public double nextDouble() {
			return Double.parseDouble(next());
		}

	}

	static long modexp(long a, long b, long p) {
		// returns a to the power b mod p by modular exponentiation

		long res = 1;
		long mult = a % p;
		while (b > 0) {
			if (b % 2 == 1) {
				res = (res * mult) % p;
			}
			b /= 2;
			mult = (mult * mult) % p;
		}

		return res;
	}

	static double log(double arg, double base) {
		// returns log of a base b, contains floating point errors, dont use for exact
		// calculations.

		if (base < 0 || base == 1) {
			throw new ArithmeticException("base cant be 1 or negative");
		}
		if (arg < 0) {
			throw new ArithmeticException("log of negative number undefined");
		}
		return Math.log10(arg) / Math.log10(base);
	}

	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);

	}

	// scope for improvement
	static ArrayList<Integer> sieveOfEratosthenes(int n) {
		boolean[] check = new boolean[n + 1];
		ArrayList<Integer> prime = new ArrayList<Integer>();
		for (long i = 2; i <= n; i++) {
			if (!check[(int) i]) {
				prime.add((int) i);
				for (long j = i * i; j <= n; j += i) {
					check[(int) j] = true;
				}
			}
		}

		return prime;
	}

	static int modInverse(int a, int n) {
		// returns inverse of a mod n by extended euclidean algorithm
		int t = 0;
		int newt = 1;
		int r = n;
		int newr = a;
		int quotient;
		int tempr, tempt;
		while (newr != 0) {
			quotient = r / newr;
			tempt = newt;
			tempr = newr;
			newr = r - quotient * tempr;
			newt = t - quotient * tempt;
			t = tempt;
			r = tempr;
		}
		if (r > 1) {
			throw new ArithmeticException("inverse of " + a + " mod " + n + " does not exist");
		} else {
			if (t < 0) {
				t += n;
			}
			return t;
		}
	}

	static long primeModInverse(long a, long n) {
		// returns inverse of a mod n by mod exponentiation, use only if n is prime
		return modexp(a, n - 2, n);
	}

	static void dfs(HashMap<Integer, ArrayList<Integer>> adj, Set<Integer> ans, Set<Integer> open,
			HashMap<String, Integer> edge, boolean[] vis, int i) {
		vis[i] = true;
		open.add(i);
		if (adj.get(i) != null) {
			for (int k : adj.get(i)) {
				if (!vis[k]) {
					dfs(adj, ans, open, edge, vis, k);
				} else if (open.contains(k)) {
					ans.add(edge.get(String.valueOf(i) + " " + String.valueOf(k)));
				}
			}
		}
		open.remove(i);
	}
}

import java.util.Scanner;

public class mainClass {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        String s = sc.next();
        int one = 0;
        int zero = 0;

        for (int i = 0; i < n; i++) {
            if(s.charAt(i)=='1'){
                one++;
            }else {
                zero++;
            }
        }
        if(zero!=one){
            System.out.println(1);
            System.out.println(s);
        }else {
            System.out.println(2);
            System.out.println(s.substring(0,s.length()-1)+" "+s.charAt(s.length()-1));
        }

    }
}

import java.util.Scanner;

public class KeanuReeeves2 {

	public static void main(String[] args) {

		Scanner sc = new Scanner(System.in);

		int n = sc.nextInt();

		String str = sc.next();
		int len = str.length();
		int zero = 0;
		int one = 0;

		if(len==1) {
			System.out.println(1);
			System.out.println(str);
		}

		for(int i = 0; i<len; i++) {

			if(str.charAt(i)=='0') {
				zero += 1;

			}
			if(str.charAt(i)=='1') {
				one += 1;

			}
		}

		if(len>1) {
		if(one != zero) {
			System.out.println(1);
			System.out.println(str);
		}
			else if(one == zero) {

			 System.out.println(2);
			 System.out.print(str.substring(0, len-1)+" "+str.charAt(len-1));

			}

			else if(zero == 0) {
				System.out.println(1);
				System.out.println(str);
			}

			else if(one== 0) {
				System.out.println(1);
				System.out.println(str);
			}
		}
	}
	}

import java.util.*;
import java.io.*;
public class A572
{
    public static void main(String [] args)
    {
        MyScanner sc = new MyScanner();
        PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
        int n = sc.nextInt();
        String s = sc.next(); int z = 0; int o = 0;
        for (int i = 0; i < n; i++) {
            if (s.charAt(i) == '0') z++; else o++;
        }
        if (z != o) {
            out.println(1);
            out.println(s);
        } else {
            out.println(2);
            out.print(s.substring(0, 1) + " " + s.substring(1));
        }
        out.close();
    }

    //-----------MyScanner class for faster input----------
    public static class MyScanner {
        BufferedReader br;
        StringTokenizer st;

        public MyScanner() {
            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;
        }

    }

}

import java.util.*;
import java.io.*;
import java.text.*;
import java.math.*;
import static java.lang.Integer.*;
import static java.lang.Double.*;
import java.lang.Math.*;

public class keanu_reeves {

	public static void main(String[] args) throws Exception {
		new keanu_reeves().run();
	}

	public void run() throws Exception {
		FastIO file = new FastIO();
		int n = file.nextInt();
		char[] c = file.next().toCharArray();
		int a = 0;
		int b = 0;
		for (int i = 0; i < n; i++) {
			if (c[i] == '1') a++;
			else b++;
		}
		if (a == b) {
			System.out.println(2);
			System.out.println(c[0] + " " + new String(c).substring(1));
		}
		else {
			System.out.println(1);
			System.out.println(c);
		}
		file.out.flush();
	}

	public static class FastIO {
		BufferedReader br;
		StringTokenizer st;
		PrintWriter out;

		public FastIO() {
			br = new BufferedReader(new InputStreamReader(System.in));
			out = new PrintWriter(System.out);
		}

		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;
		}

		void print(Object o) {
			out.print(o);
		}

		void println(Object o) {
			out.println(o);
		}

		void printf(String s, Object... o) {
			out.printf(s, o);
		}
	}

	public static long pow(long n, long p, long mod) {
		if (p == 0)
			return 1;
		if (p == 1)
			return n % mod;
		if (p % 2 == 0) {
			long temp = pow(n, p / 2, mod);
			return (temp * temp) % mod;
		} else {
			long temp = pow(n, (p - 1) / 2, mod);
			temp = (temp * temp) % mod;
			return (temp * n) % mod;

		}
	}

	public static long pow(long n, long p) {
		if (p == 0)
			return 1;
		if (p == 1)
			return n;
		if (p % 2 == 0) {
			long temp = pow(n, p / 2);
			return (temp * temp);
		} else {
			long temp = pow(n, (p - 1) / 2);
			temp = (temp * temp);
			return (temp * n);

		}
	}

	public static long gcd(long x, long y) {
		if (x == 0)
			return y;
		else
			return gcd(y % x, x);
	}

	public static boolean isPrime(int n) {
		if (n <= 1)
			return false;
		if (n <= 3)
			return true;

		if (n % 2 == 0 || n % 3 == 0)
			return false;

		for (int i = 5; i * i <= n; i = i + 6)
			if (n % i == 0 || n % (i + 2) == 0)
				return false;

		return true;
	}
}

import java.io.*;
import java.util.*;
public class d2prac implements Runnable
{
	private boolean console=false;

	public void solve()
	{
		int i;
		int n=in.ni();
		String a=in.ns();
		if(n%2!=0)
		{
			out.println(1); out.println(a);
			return;
		}
		int zc=0,oc=0;
		for(i=0;i<n;i++)
		{
			if(a.charAt(i)=='0')
				zc++;
			else
				oc++;
		}
		if(zc==oc)
		{
			out.println(2);
			out.println(a.charAt(0)+" "+a.substring(1));
		}
		else
		{
			out.println(1); out.println(a);
		}
	}
	@Override
	public void run() {
		try {  init();  }
		catch (FileNotFoundException e) {  e.printStackTrace();   }

		int t= 1;

		while (t-->0) {
			solve();
			out.flush(); }
	}
	private FastInput in;    private PrintWriter out;
	public static void main(String[] args) throws Exception {	 new d2prac().run();	 }

	private void init() throws FileNotFoundException {
		InputStream inputStream = System.in; 	 OutputStream outputStream = System.out;
		try {  if (!console && System.getProperty("user.name").equals("sachan")) {
			outputStream = new FileOutputStream("/home/sachan/Desktop/output.txt");
			inputStream = new FileInputStream("/home/sachan/Desktop/input.txt");   	}
		}	catch (Exception ignored) {	}
		out = new PrintWriter(outputStream); 	 in = new FastInput(inputStream);
	}
	static class FastInput { InputStream obj;
	public FastInput(InputStream obj) {	this.obj = obj;	}
	byte inbuffer[] = new byte[1024];  int lenbuffer = 0, ptrbuffer = 0;
	int readByte() { if (lenbuffer == -1) throw new InputMismatchException();
	if (ptrbuffer >= lenbuffer) { ptrbuffer = 0;
	try { lenbuffer = obj.read(inbuffer);  }
	catch (IOException e) { throw new InputMismatchException(); } }
	if (lenbuffer <= 0) return -1;return inbuffer[ptrbuffer++]; }

	String ns() { int b = skip();StringBuilder sb = new StringBuilder();
	while (!(isSpaceChar(b)))	  { sb.appendCodePoint(b);b = readByte(); }return sb.toString();}

	int ni() { int num = 0, b;boolean minus = false;
	while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-')) ;
	if (b == '-') { minus = true;b = readByte(); }
	while (true) { if (b >= '0' && b <= '9') { num = num * 10 + (b - '0'); } else {
		return minus ? -num : num; }b = readByte(); }}

	long nl() { long num = 0;int b;boolean minus = false;
	while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-')) ;
	if (b == '-') { minus = true;b = readByte(); }
	while (true) { if (b >= '0' && b <= '9') { num = num * 10L + (b - '0'); } else {
		return minus ? -num : num; }b = readByte(); } }

	boolean isSpaceChar(int c) { return (!(c >= 33 && c <= 126)); }
	int skip() { int b;while ((b = readByte()) != -1 && isSpaceChar(b)) ;return b; }
	float nf() {return Float.parseFloat(ns());}
	double nd() {return Double.parseDouble(ns());}
	char nc() {return (char) skip();}
	}
}

import java.util.Scanner;

public class main {
public static void main(String args[]) {
	Scanner sc = new Scanner(System.in);
	int l = sc.nextInt();
	sc.nextLine();
	String s = sc.nextLine();
	int si = (int)l/2;
	int n=1;
	int nu[] = new int[]{0,0};
	int num[] = new int[]{0,0};
	int num1[] = new int[]{0,0};
	for(int j = 0; j < s.length(); j++){
	    nu[s.charAt(j)-'0']++;
	}
	if(l==1){
		System.out.println(n);
		System.out.println(s);
	}
	else if(nu[0]!=nu[1]) {
		System.out.println(n);
		System.out.println(s);
	}
	else {
		for(int i=0;i<l/2;i++) {
			n=2;
			String sub1 = s.substring(0,si);
			String sub2 = s.substring(si,l);
			for(int j = 0; j < sub1.length(); j++){
			    num[s.charAt(j)-'0']++;
			}
			for(int j = 0; j < sub2.length(); j++){
			    num1[s.charAt(j)-'0']++;
			}
			if((num[0]!=num[1])&&(num1[0]!=num1[1])) {
				System.out.println(n);
				System.out.println(sub1+" "+sub2);
				break;
			}
			si--;
		}
	}
  }
}

import java.util.*;import java.io.*;
public class Main
{

	static boolean isGood(String s){
		int cnt0=0,cnt1=0;
		for(int i=0;i<s.length();i++){
			char c=s.charAt(i);
			if(c=='1')
				cnt1++;
			else
				cnt0++;
		}
		if(cnt1!=cnt0)
			return true;
		return false;
	}
	public static void process()throws IOException
    {
    	int n=ni();
    	String s=nln();
    	if(isGood(s)){
    		pn(1);
    		pn(s);
    		return ;
    	}
    	// if(n==1){
    	// 	pn(1);
    	// 	pn(s);
    	// 	return ;
    	// }
    	for(int i=1;i<n;i++){
    		if(isGood(s.substring(0,i)) && isGood(s.substring(i))){
    			pn(2);
    			pn(s.substring(0,i)+" "+s.substring(i));
    			return ;
    		}
    	}
    	pn(0);
    }

    static FastReader sc=new FastReader();
    //static AnotherReader sc;

    public static void main(String[]args)throws IOException
    {
        //sc=new AnotherReader();
        int t=1;
        while(t-->0)
            process();
        System.out.flush();
        System.out.close();
    }

    static boolean multipleTC=false;
    static void pn(Object o){System.out.println(o);}
    static void p(Object o){System.out.print(o);}
    static void pni(Object o){System.out.println(o);System.out.flush();}
    static int ni()throws IOException{return sc.nextInt();}
    static long nl()throws IOException{return sc.nextLong();}
    static double nd()throws IOException{return sc.nextDouble();}
    static String nln()throws IOException{return sc.nextLine();}
    static long gcd(long a, long b)throws IOException{return (b==0)?a:gcd(b,a%b);}
    static int gcd(int a, int b)throws IOException{return (b==0)?a:gcd(b,a%b);}
    static int bit(long n)throws IOException{return (n==0)?0:(1+bit(n&(n-1)));}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    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;}}

    static class AnotherReader{BufferedReader br; StringTokenizer st;
    AnotherReader()throws FileNotFoundException{
    br = new BufferedReader(new FileReader("input.txt"));}
    String next()throws IOException{
    while (st == null || !st.hasMoreElements()) {try{
    st = new StringTokenizer(br.readLine());}
    catch (IOException  e){ e.printStackTrace(); }}
    return st.nextToken(); } int nextInt() throws IOException{
    return Integer.parseInt(next());}
    long nextLong() throws IOException
    {return Long.parseLong(next());}
    double nextDouble()throws IOException { return Double.parseDouble(next()); }
    String nextLine() throws IOException{ String str = ""; try{
    str = br.readLine();} catch (IOException e){
    e.printStackTrace();} return str;}}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
}

import java.util.*;
public class Main {

    public static void main(String[] args) {
       Scanner input=new Scanner(System.in);
       int n=input.nextInt();
       String s=input.next();

       if(n%2!=0)
            System.out.println("1\n"+s);
       else
       {     int one=0,zero=0; for(int i=s.length()-1;i>=0;i--) {  if(s.charAt(i)!='0')  one++; else zero++;  }
             if(one!=zero)  System.out.println("1\n"+s);
             else System.out.println("2\n"+s.substring(0,1)+" "+s.substring(1));}
    }
}

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        String s = scan.next();

        int count1=0,count0=0;

        for(int i=0;i<n;i++){
            if(s.charAt(i)=='1')
                count1++;
            else
                count0++;
        }
        if(count1!=count0){
            System.out.print(1+"\n"+s);
        }
        else{
            System.out.println(2);
            for(int i=0;i<n-1;i++){
                System.out.print(s.charAt(i));
            }
            System.out.print(" ");
            System.out.print(s.charAt(n-1));
        }
    }
}

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

public class cf1{
    public static void main (String[] args){
        Scanner sc = new Scanner(System.in);
        int n   = sc.nextInt() ;
        String input = sc.next();
        char[] arr = input.toCharArray();

        int count0 = 0;
        int count1 = 0;
        ArrayList<String> result = new ArrayList<String>();

        for(int i=0;i<input.length();i++){
            if(input.charAt(i)=='1')count1++;
            else count0++;
        }

        if(count0==count1){
            System.out.println(2);
            System.out.println(input.charAt(0));
            for(int i=1;i<input.length();i++)System.out.print(input.charAt(i));
        }
        else{
            System.out.println(1);
            System.out.println(input);
        }

    }
}

//package codeforces;
import java.util.Scanner;
public class ex6 {
public static void main(String[] args) {
	Scanner scan = new Scanner(System.in);
	int a = scan.nextInt();
	String nb =scan.next();
	String nw = "";
	int x=0,y=0;
	int x1=0,y2=0;
	for (int i = 0; i < nb.length(); i++) {
		char b = nb.charAt(i);
		if(b=='1') x++;
		else y++;

	}

	if(x!=y) { System.out.println("1");
	System.out.println(nb);
	}
	else {
		System.out.println("2");
		System.out.println(nb.substring(0,1)+" "+nb.substring(1));
	}

}}

import java.io.*;
import java.util.*;
public class GFG {
	public static void main (String[] args) {
	    Scanner sc=new Scanner(System.in);
	    int n=sc.nextInt();
	    int c=0;
	    String ch=sc.next();
	    for(int i=0;i<n;i++)
	    {
	        if(ch.charAt(i)=='0')
	            c++;
	        else
	            c--;
	    }
	    if(c!=0)
	        System.out.println("1 \n"+ ch);
	   else
	        System.out.println("2 \n"+ch.substring(0,n-1)+" "+ch.substring(n-1));
	}
}

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

public class TestClass{

    public static void main(String args[])throws Exception
    {
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int i;
        int z[]=new int [n];
        int o[]=new int [n];

        char a[]=sc.next().toCharArray();
        int sum0=0,sum1=0;
        for(i=0;i<n;i++){
            if(a[i]=='0'){
                sum0++;
            }
            else{
                sum1++;
            }
            z[i]=sum0;
            o[i]=sum1;
        }
        int j,k;
        if(sum0!=sum1 || n==1){
            System.out.println(1);
            String s=new String(a);
            System.out.println(s);
        }
        else{
            String s=new String(a);
            for(i=1;i<n;i++){
                for(j=0;j<n-1;j=j+i){
                    if(z[n-1]-z[j]!=o[n-1]-o[j]){
                        System.out.println(2);
                        if(j<n-i){
                            System.out.println(s.substring(0,j+1)+" "+s.substring(j+1,n));
                        }
                        return;
                    }
                }
            }
        }
    }

}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {
	public static void main(String[] args) throws NumberFormatException, IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

		int n = Integer.parseInt(br.readLine());
		String str = br.readLine();

		int count0 = 0;
		int count1 = 0;
		for(int i=0; i<n; i++) {
			if(str.charAt(i) == '0') ++count0;
			else if(str.charAt(i) == '1') ++count1;
		}

		if(count0 != count1) {
			System.out.println(1);
			System.out.println(str);
		} else {
			System.out.println(2);
			System.out.print(str.substring(0, 1));
			System.out.print(" ");
			System.out.println(str.substring(1));
		}
	}
}

//package codeforce;

import java.util.Scanner;

public class GoodString {
 public static void main(String[] args) {
	 Scanner in = new Scanner(System.in);
	 int n = in.nextInt();
	 String s = in.next();
	 char[] que = s.toCharArray();
	 int c0=0,c1=0;
	 for(int i=0;i<que.length;i++) {
		 if(que[i]=='0')
			 c0++;
		 else
			 c1++;
	 }
	 if(c0!=c1) {
		 System.out.println("1");
		 System.out.println(s);
	 }else {
		 System.out.println("2");
		 System.out.println(s.substring(0,s.length()-1)+" "+s.substring(s.length()-1));
	 }
 }
}

import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;

public class cf_572_2_a {
    public static void main(String[] args) throws Exception {
        FastScanner f = new FastScanner();
        int T = f.nextInt();
//        while (T-- > 0) {
//            int n = f.nextInt();
//            int[] a = f.nextIntArray(n);
//
//        }
        String a = f.next();
        int zeros = 0;
        int ones = 0;
        for (int i = 0; i < T; i++) {
            if (a.charAt(i)=='0')
                zeros++;
            else ones++;
        }

        if (zeros==ones){
            System.out.println("2");
            System.out.print(a.substring(0,T-1) + " " + a.charAt(T-1));

        }
        else {
            System.out.println("1");
            System.out.println(a);
        }
    }
}

class FastScanner {
    public int BS = 1<<16;
    public char NC = (char)0;
    byte[] buf = new byte[BS];
    int bId = 0, size = 0;
    char c = NC;
    double num = 1;
    BufferedInputStream in;

    public FastScanner() {
        in = new BufferedInputStream(System.in, BS);
    }

    public FastScanner(String s) {
        try {
            in = new BufferedInputStream(new FileInputStream(new File(s)), BS);
        }
        catch (Exception e) {
            in = new BufferedInputStream(System.in, BS);
        }
    }

    public char nextChar(){
        while(bId==size) {
            try {
                size = in.read(buf);
            }catch(Exception e) {
                return NC;
            }
            if(size==-1)return NC;
            bId=0;
        }
        return (char)buf[bId++];
    }

    public int nextInt() {
        return (int)nextLong();
    }

    public long nextLong() {
        num=1;
        boolean neg = false;
        if(c==NC)c=nextChar();
        for(;(c<'0' || c>'9'); c = nextChar()) {
            if(c=='-')neg=true;
        }
        long res = 0;
        for(; c>='0' && c <='9'; c=nextChar()) {
            res = (res<<3)+(res<<1)+c-'0';
            num*=10;
        }
        return neg?-res:res;
    }

    public double nextDouble() {
        double cur = nextLong();
        return c!='.' ? cur:cur+nextLong()/num;
    }

    public String next() {
        StringBuilder res = new StringBuilder();
        while(c<=32)c=nextChar();
        while(c>32) {
            res.append(c);
            c=nextChar();
        }
        return res.toString();
    }

    public String nextLine() {
        StringBuilder res = new StringBuilder();
        while(c<=32)c=nextChar();
        while(c!='\n') {
            res.append(c);
            c=nextChar();
        }
        return res.toString();
    }

    public boolean hasNext() {
        if(c>32)return true;
        while(true) {
            c=nextChar();
            if(c==NC)return false;
            else if(c>32)return true;
        }
    }

    public int[] nextIntArray(int n) {
        int[] res = new int[n];
        for(int i = 0; i < n; i++) res[i] = nextInt();
        return res;
    }

    public char[] nextCharArray(int n) {
        char[] res = new char[n];
        for (int i = 0; i < n; i++) {
            res[i] = nextChar();
        }
        return res;
    }

}

import java.util.Scanner;

public class Main {

    public static void main(String[] args)  {

        Scanner scanner = new Scanner(System.in);
        int zeros = 0;
        int ones = 0;
        String lol = scanner.nextLine();
        String str = scanner.nextLine();
        for (int i = 0; i < str.length(); i++){
             if (str.charAt(i) == '0'){
                 zeros++;
             } else{
                 ones++;
             }
        }
        if (zeros == ones){
            System.out.println(2);
            System.out.print(str.charAt(0));
            System.out.print(" ");
            System.out.println(str.substring(1));
        } else{
            System.out.println(1);
            System.out.println(str);
        }
    }
}

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

public class june5_3
{

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

		FastReader scan=new FastReader();
		 int n=scan.nextInt();
		 String s=scan.next();
		 int count1=0;
		 int count0=0;
		 int min=Integer.MAX_VALUE;
		 for(int i=0;i<n;i++){
			if(s.charAt(i)=='0') count0++;
			else count1++;
		 }
		 if(count1!=count0) {
			 System.out.println(1);
			 System.out.println(s);
		 }
		 else{
			 String ans="";
			 System.out.println(2);
			 ans+=s.charAt(0);
			 ans+=" ";
			 ans+=s.substring(1, n);
			 System.out.println(ans);
		 }
	}

		 static class FastReader{
	          BufferedReader in;
	          StringTokenizer st;
	          public FastReader(){
	              in=new BufferedReader(new InputStreamReader(System.in));
	          }
	          String next(){
	              while(st==null || !st.hasMoreElements()){
	                  try{
	                      st=new StringTokenizer(in.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 str19 = "";
	            try{
	                str19 = in.readLine();
	            }
	            catch (IOException e){
	                e.printStackTrace();
	             }
	            return str19;
	        }
	      }
	}

import java.util.Scanner;
public class A{
    static int count(char a,String list ){
        int res=0;
        for (int i=0;i<list.length();i++){
            if (list.charAt(i)==a){
                res=res+1;
            }
        }
        return res;
    }
    public static void main(String args[]){
        Scanner in=new Scanner(System.in);
        int n=in.nextInt();
        int res=0;
        String list= in.next();
        if (count('1',list)!=count('0',list)){
            System.out.println(1);
            res=1;
        }
        else if (n>1){
        System.out.println(2);}
        else{
            res=1;
            System.out.println(1);
        }
        if (res!=1){

        System.out.print(list.charAt(0));
        System.out.print(" ");
        for (int i=1;i<list.length();i++){
            System.out.print(list.charAt(i));}}
        else{
            System.out.println(list);
        }
}
}

import java.util.Scanner;

public class Main {

	public static void main(String[] args)
	{
		Scanner s=new Scanner(System.in);

		int n=s.nextInt();

		String str=s.next();

		int[] zero=new int[n];
		int[] one=new int[n];

		for(int i=0;i<n;i++)
		{
			if(str.charAt(i)=='0')
			{
				if(i==0)
				{
					zero[i]=1;
				}
				else
				{
					zero[i]=zero[i-1]+1;
					one[i]=one[i-1];
				}
			}
			else
			{
				if(i==0)
				{
					one[i]=1;
				}
				else
				{
					one[i]=one[i-1]+1;
					zero[i]=zero[i-1];
				}
			}
		}

		int index=-1;

		for(int j=n-1;j>=0;j--)
		{
			if(zero[j]!=one[j]&&zero[n-1]-zero[j]!=one[n-1]-one[j])
			{
				index=j;
				break;
			}
		}

		if(n==1)
		{
			System.out.println(1);
			System.out.println(str);
		}
		else if(zero[n-1]!=one[n-1])
		{
			System.out.println(1);
			System.out.println(str);
		}
		else
		{
			System.out.println(2);
			System.out.println(str.substring(0,index+1)+" "+str.substring(index+1));
		}

	}

}

import java.util.HashSet;
import java.util.Scanner;

public class Main1189A {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while (in.hasNext()) {
            int n = in.nextInt();
            String s = in.next();

            if (n % 2 == 1 || isOdd(s)) {
                System.out.println("1\n"+s);
            } else {
                System.out.println("2\n" + s.charAt(0) + " " + s.substring(1));
            }
        }
    }

    public static boolean isOdd(String s) {
        char[] ch = s.toCharArray();
        int one = 0;
        int zero = 0;
        for (char c : ch) {
            if (c == '0') {
                zero++;
            } else {
                one++;
            }
        }
        if (zero== 0 || one == 0) {
            return true;
        }
        return ((zero + one) % 2 == 0) && (zero != one);
    }

}

import java.util.HashSet;
import java.util.Scanner;

public class Main1189A {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while (in.hasNext()) {
            int n = in.nextInt();
            String s = in.next();

            if (n % 2 == 1 || isSame(s) || isOdd(s)) {
                System.out.println(1);
                System.out.println(s);
            } else {
                System.out.println(2);
                System.out.println(s.charAt(0) + " " + s.substring(1));
            }
        }
    }

    public static boolean isSame(String s) {
        HashSet<Character> set = new HashSet<>();
        char[] ch = s.toCharArray();
        for (char c : ch) {
            set.add(c);
        }
        return set.size() == 1;
    }

    public static boolean isOdd(String s) {
        char[] ch = s.toCharArray();
        int one = 0;
        int zero = 0;
        for (char c : ch) {
            if (c == '0') {
                zero++;
            } else {
                one++;
            }
        }
        return ((zero + one) % 2 == 0) && (zero != one);
    }

}

//package godiji;

import java.util.Scanner;
import java.util.HashMap;
import java.util.TreeMap;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Stack;

public class pac1 {

	static Scanner scn = new Scanner(System.in);
	static long cunt = 0;

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int t = scn.nextInt(),m;
			String str=scn.next();
			int n=str.length(),one=0,zer=0;
			for(int i=0;i<n;i++)
			{
				if(str.charAt(i)=='0')
					zer++;
				else one++;
			}
			if(one!=zer||n==1)
			{
				System.out.println("1");
				System.out.println(str);
			}
			else
			{
				System.out.println("2");
				System.out.println(str.substring(0, 1)+" "+str.substring(1));
		}

	}
	public static String reverse(String str)
	{	int n=str.length();
		char ch[]=str.toCharArray();
		char temp=' ';
		for(int i=0;i<n/2;i++)
		{
			temp=ch[i];
			ch[i]=ch[n-i-1];
			ch[n-i-1]=temp;
		}
		StringBuilder sb=new StringBuilder();
		for(int i=0;i<n;i++)
			sb.append(ch[i]);
		return sb.toString();
	}
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        AKeanuReeves solver = new AKeanuReeves();
        solver.solve(1, in, out);
        out.close();
    }

    static class AKeanuReeves {
        public void solve(int testNumber, InputReader in, PrintWriter out) {
            int n = in.nextInt();
            String s = in.next();
            int oneC = 0;
            int zeroC = 0;
            for (int i = 0; i < s.length(); i++) {
                if (s.charAt(i) == '1')
                    oneC++;
                else
                    zeroC++;
            }
            if (oneC != zeroC) {
                out.println(1);
                out.println(s);
            } else {
                out.println(2);
                out.println(s.substring(0, n - 1) + " " + s.substring(n - 1));
            }
        }

    }

    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());
        }

    }
}

import java.util.HashSet;
import java.util.Scanner;

public class Main1189A {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while (in.hasNext()) {
            int n = in.nextInt();
            String s = in.next();

            if (n % 2 == 1 || isOdd(s)) {
                System.out.println(1);
                System.out.println(s);
            } else {
                System.out.println(2);
                System.out.println(s.charAt(0) + " " + s.substring(1));
            }
        }
    }

    public static boolean isOdd(String s) {
        char[] ch = s.toCharArray();
        int one = 0;
        int zero = 0;
        for (char c : ch) {
            if (c == '0') {
                zero++;
            } else {
                one++;
            }
        }
        if (zero== 0 || one == 0) {
            return true;
        }
        return ((zero + one) % 2 == 0) && (zero != one);
    }

}

import java.util.Scanner;

public class JavaApplication156 {

    public static void main(String[] args) {
       Scanner sc = new Scanner(System.in);

       int n = sc.nextByte();
       String s =sc.next();
       int count = 0;
       int count2 = 0;
       for(int i=0; i<s.length(); i++){
           if(s.charAt(i) == '1') count++;
       }

       count2 = s.length() - count;

       if(count2 != count){
           System.out.println("1"+"\n"+s);
       }else{
           System.out.println("2"+"\n"+s.charAt(0)+" "+s.substring(1,s.length()));
       }

    }

}

import java.util.*;
public class Q1
{
	public static void main(String[]args)
	{
		Scanner sc = new Scanner(System.in);
		//int t = sc.nextInt();
		int n = sc.nextInt();
		String str = sc.next();
		String [] ch = str.split("");
		//int [] arr = new int[n];
		int zero = 0;
		int one = 0;
		for(int i=0;i<n;i++)
		{
			//arr[i] = Integer.parseInt(ch[i]);
			if(ch[i].equals("0"))
			{
				zero++;
			}
			else
			{
				one++;
			}
		}
		if(zero!=one)
		{
			System.out.println(1);
			System.out.println(str);
		}
		else
		{
			System.out.println(2);
			System.out.println(str.charAt(0) + " "+str.substring(1));
		}
	}
}

import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.StringTokenizer;

public class cf {
	public static class FastReader {
		BufferedReader br;
		StringTokenizer st;
		//it reads the data about the specified point and divide the data about it ,it is quite fast
		//than using direct

		public FastReader() {
			br = new BufferedReader(new InputStreamReader(System.in));
		}

		String next() {
			while (st == null || !st.hasMoreTokens()) {
				try {
					st = new StringTokenizer(br.readLine());
				} catch (Exception r) {
					r.printStackTrace();
				}
			}
			return st.nextToken();
		}

		int nextInt() {
			return Integer.parseInt(next());//converts string to integer
		}

		double nextDouble() {
			return Double.parseDouble(next());
		}

		long nextLong() {
			return Long.parseLong(next());
		}

		String nextLine() {
			String str = "";
			try {
				str = br.readLine();
			} catch (Exception r) {
				r.printStackTrace();
			}
			return str;
		}
	}
	static int sum(int n)
	{int s=0;
		while(n!=0)
		{
			s+=n%10;
			n/=10;
		}
		return s;
	}

	public static PrintWriter out = new PrintWriter (new BufferedOutputStream(System.out));
	static class Pair{
        int x;int y;
        Pair(int x,int y){
            this.x=x;
            this.y=y;
          //  this.i=i;
        }
    }
	static int no(String s)
	{
		int one=0;
		for(int i=0;i<s.length();i++)
		{
			if(s.charAt(i)=='1')
				one++;
		}
		return one;
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		HashMap<Integer,Integer>map=new HashMap<Integer,Integer>();
		ArrayList<String>list=new ArrayList<String>();
		FastReader in=new FastReader();
int n=in.nextInt();
String s=in.next();String str="";
int i=1;
while(true&&n!=1)
{int t=0;int y=0;
	String s1=s.substring(i,n);
	String s2=s.substring(0,i);
	if(no(s1)!=(s1.length()-no(s1)))
		t=1;
	if(no(s2)!=(s2.length()-no(s2)))
		y=1;
	if(t==1&&y==1)
		{str=s2+" "+s1;
		break;
		}
	i++;
	if(i==n)
		break;
}
int one=no(s);
int zero=s.length()-one;
if(n==1)
{
System.out.println(1);
System.out.println(s);
}
else if(zero==one)
{System.out.println(2);
System.out.println(s.charAt(0)+" "+s.substring(1,n));}

else
{
	System.out.println(1);
	System.out.println(s);
}

	}

}

import java.io.*;
import java.util.*;
import java.math.*;
import java.lang.*;
import static java.lang.Math.*;

public class Main implements Runnable
{
	static class InputReader
	{
		private InputStream stream;
		private byte[] buf = new byte[1024];
		private int curChar;
		private int numChars;
		private SpaceCharFilter filter;
		private BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

		public InputReader(InputStream stream)
		{
			this.stream = stream;
		}

		public int read()
		{
			if (numChars==-1)
				throw new InputMismatchException();

			if (curChar >= numChars)
			{
				curChar = 0;
				try
				{
					numChars = stream.read(buf);
				}
				catch (IOException e)
				{
					throw new InputMismatchException();
				}

				if(numChars <= 0)
					return -1;
			}
			return buf[curChar++];
		}

		public String nextLine()
		{
			String str = "";
			try
			{
				str = br.readLine();
			}
			catch (IOException e)
			{
				e.printStackTrace();
			}
			return str;
		}
		public int nextInt()
		{
			int c = read();

			while(isSpaceChar(c))
				c = read();

			int sgn = 1;

			if (c == '-')
			{
				sgn = -1;
				c = read();
			}

			int res = 0;
			do
			{
				if(c<'0'||c>'9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			}
			while (!isSpaceChar(c));

			return res * sgn;
		}

		public long nextLong()
		{
			int c = read();
			while (isSpaceChar(c))
				c = read();
			int sgn = 1;
			if (c == '-')
			{
				sgn = -1;
				c = read();
			}
			long res = 0;

			do
			{
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			}
			while (!isSpaceChar(c));
				return res * sgn;
		}

		public double nextDouble()
		{
			int c = read();
			while (isSpaceChar(c))
				c = read();
			int sgn = 1;
			if (c == '-')
			{
				sgn = -1;
				c = read();
			}
			double res = 0;
			while (!isSpaceChar(c) && c != '.')
			{
				if (c == 'e' || c == 'E')
					return res * Math.pow(10, nextInt());
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			}
			if (c == '.')
			{
				c = read();
				double m = 1;
				while (!isSpaceChar(c))
				{
					if (c == 'e' || c == 'E')
						return res * Math.pow(10, nextInt());
					if (c < '0' || c > '9')
						throw new InputMismatchException();
					m /= 10;
					res += (c - '0') * m;
					c = read();
				}
			}
			return res * sgn;
		}

		public String readString()
		{
			int c = read();
			while (isSpaceChar(c))
				c = read();
			StringBuilder res = new StringBuilder();
			do
			{
				res.appendCodePoint(c);
				c = read();
			}
			while (!isSpaceChar(c));

			return res.toString();
		}

		public boolean isSpaceChar(int c)
		{
			if (filter != null)
				return filter.isSpaceChar(c);
			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
		}

		public String next()
		{
			return readString();
		}

		public interface SpaceCharFilter
		{
			public boolean isSpaceChar(int ch);
		}
	}
	public static void main(String args[]) throws Exception
	{
		new Thread(null, new Main(),"Main",1<<27).start();
	}

	public void run(){
        InputReader sc=new InputReader(System.in);
        PrintWriter out=new PrintWriter(System.out);
        int n=sc.nextInt();
        String s=sc.next();
            char a[]=s.toCharArray();
            int one=0;
            int zero=0;
            for(int i=0;i<n;i++)
            {
                if(a[i]=='1')
                {
                    one=one+1;
                }
                if(a[i]=='0')
                {
                    zero=zero+1;
                }
            }
            if(one!=zero)
            {
                out.println("1");
                out.println(s.substring(0,n));
            }
            else{
            if(n==1)
            {
                out.println("1");
                out.println(s.substring(0,1));
            }
            else
            {
                out.println("2");
            out.println(s.substring(0,n-1)+" "+s.substring(n-1,n));
            }
            }
        out.flush();
		out.close();
	}
}

import java.util.Scanner;

public class A {
	public static void main(String... g) {
		Scanner s = new Scanner(System.in);
		int n = s.nextInt();
		String z = s.next();
		if (ok(z)) {
			System.out.println(1);
			System.out.println(z);
		} else {
			for (int i = 0; i < z.length(); i++) {
				String a = z.substring(0, i);
				String b = z.substring(i);
				if (ok(a) && ok(b)) {
					System.out.println(2);
					System.out.println(a + " " + b);
					return;
				}
			}
		}
	}

	static boolean ok(String z) {
		int a = 0, b = 0;
		for (char c : z.toCharArray()) {
			if (c == '0') {
				a++;
			} else {
				b++;
			}
		}
		return a != b;
	}
}

import java.util.ArrayList;
import java.util.Scanner;

public class CF1189A {

	public static void main(String[] args) {
		Scanner s = new Scanner(System.in);
		int n = s.nextInt();
		s.nextLine();
		String line = s.nextLine();
		if(isGood(line)) {
			System.out.println(1);
			System.out.println(line);
		}else {
			System.out.println(2);
			for (int i = 1; i <= line.length()-1; i++) {
				String a = line.substring(0, line.length()-i);
				String b  = line.substring(line.length()-i, line.length());
				if(isGood(a)&&isGood(b)) {
					System.out.println(a+" "+b);
					break;
				}
			}

		}

	}
	static boolean isGood(String s) {
		int countzero=0;
		int countone=0;
		for (int i = 0; i < s.length(); i++) {
			if(s.charAt(i)=='0') {
				countzero++;
			}else {
				countone++;
			}
		}
		if(countone!=countzero) {
			return true;
		}else {
			return false;
		}
	}
}

import java.util.*;
import java.lang.*;
import java.io.*;
import java.math.*;
//BigInteger A;
//A= BigInteger.valueOf(54);
//ArrayList<Integer> a=new ArrayList<>();
//TreeSet<Integer> ts=new TreeSet<>();
//HashMap<Integer,Integer> hm=new HashMap<>();
public final class Minimal
{
    public static void main(String[]args)
    {
        FastReader ob=new FastReader();
        int n=ob.nextInt();
        String s=ob.next();
        if(n%2==0)
        {
            int c0=0,c1=0;
            for(int i=0;i<s.length();i++)
            {
                if(s.charAt(i)=='0')
                ++c0;
                else
                ++c1;
            }
            if(n==c0||n==c1||c0!=c1)
            {
                System.out.println("1");
                System.out.println(s);
                return;
            }
            String s1=s.substring(0,1);
            String s2=s.substring(1);
            System.out.println("2");
            System.out.println(s1+" "+s2);
        }
        else
        {
            System.out.println("1");
            System.out.println(s);
        }
    }
}
class FastReader {
    BufferedReader br;
    StringTokenizer st;
    public FastReader() {
        br = new BufferedReader(new InputStreamReader(System.in));
    }

    public String next() {
        while (st == null || !st.hasMoreElements()) {
            try {
                st = new StringTokenizer(br.readLine());
            } catch (IOException e)  {
                e.printStackTrace();
            }
        }
        return st.nextToken();
    }
    public String nextLine()
    {
        String s="";
        try {
        s=br.readLine();
        } catch (IOException e)  {
                e.printStackTrace();
            }
        return s;
    }
    public int nextInt() {
        return Integer.parseInt(next());
    }
    public long nextLong() {
        return Long.parseLong(next());
    }
    public double nextDouble() {
        return Double.parseDouble(next());
    }
}

import java.util.*;
public class Main {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        ArrayList<String> arrayList=new ArrayList<>();
        int n=scan.nextInt();
        String str=scan.next();
        char arraystr[]=str.toCharArray();
        int sum0=0;
        int sum1=0;
        for (int i=0;i<n;i++){
            if(arraystr[i]=='0'){
                sum0++;
            }
            else {
                sum1++;
            }
        }
        if (sum0==sum1){
            System.out.println(2);
            System.out.print(str.charAt(0)+" ");
            for (int i=1;i<n;i++){
                System.out.print(str.charAt(i));
            }
        }
        else {
            System.out.println(1);
            System.out.println(str);
        }

    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class A
{
	public static void main(String args[])throws IOException
	{
		BufferedReader BR=new BufferedReader (new InputStreamReader(System.in));

		int n = Integer.parseInt(BR.readLine());
		String str=BR.readLine();

		int o=0,z=0;
		for(int i=0;i<n;i++)
		{
			char ch=str.charAt(i);
			if(ch=='1')
				o++;
			if(ch=='0')
				z++;
		}

		if(o==z)
		{
			System.out.println(2);
			System.out.println(str.substring(0,n-1)+" "+str.charAt(n-1));
		}
		else
		{
			System.out.println(1);
			System.out.println(str);
		}

	}
}

import java.util.Scanner;

public class A1189 {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int N = in.nextInt();
        String S = in.next();
        int zeros = 0;
        for (int i=0; i<N; i++) {
            if (S.charAt(i) == '0') {
                zeros++;
            }
        }
        if (N%2 == 0 && 2*zeros == N) {
            System.out.println("2");
            System.out.println(S.charAt(0) + " " + S.substring(1));
        } else {
            System.out.println("1");
            System.out.println(S);
        }
    }

}

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
/**
 *
 * @author BATCH1
 */
import java.util.*;
public class ques1 {
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int c= 0;
        String s = sc.next();
        for(int i =0;i<n;i++)
            if(s.charAt(i)=='1')
                c++;
        if(c*2!=n){
            System.out.println(1);
            System.out.println(s);
        }
        else{
            System.out.println(2);
            System.out.println(s.substring(0,1) + " " + s.substring(1));
        }
    }
}

import java.util.Scanner;

public class Main{
    public static void main(String[] args){
        Scanner key = new Scanner(System.in);

        int a = key.nextInt();
        key.nextLine();
        String s = key.nextLine();

        int count1=0,count0=0;
        for(int i = 0;i<a;i++)
        {
            if(s.charAt(i) == '1')
            {
                count1++;
            }

            if(s.charAt(i) == '0')
            {
                count0++;
            }
        }

        if(count0 != count1)
        {
            System.out.print("1" + "\n" + s);
        }
        else
        {
            System.out.print("2" + "\n" + s.charAt(0) + " ");
            for(int i=1;i<a;i++){
                System.out.print(s.charAt(i));
            }
        }
    }
}

import java.util.Scanner;

/**
 * Created by Rukshar Alam on 12/12/2019.
 */
public class Reeves_1189A {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);int n = sc.nextInt();sc.nextLine();
        String str = sc.nextLine();
        if(n%2==1){
            System.out.println("1");
            System.out.println(str);
        }
        else{
            int numOnes = 0;
            for(int i =0;i<n;i++){
                if(str.charAt(i)=='1') numOnes++;
            }

            int numZero = n-numOnes;
            if(numOnes!=numZero) {
                System.out.println("1");
                System.out.println(str);
            }else {
                System.out.println("2");
                System.out.print(str.substring(0,n-1)+" "+str.substring(n-1));
            }

        }
    }
}

import java.util.*;

public class geek {

    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        int n=s.nextInt();
        String st=s.next();
        int zeroes=0;
        int ones=0;
        for(int i=0;i<n;i++){
            if(st.charAt(i)=='0'){
                zeroes++;
            }else{
                ones++;
            }
        }
        if(zeroes!=ones){
            System.out.println("1\n"+st);
        }else {
            if (n == 2) {
                System.out.println("2\n" + st.charAt(0) + " " + st.charAt(1));
            } else {
                System.out.println("2\n" + st.substring(0, n - 1) + " " + st.charAt(n - 1));
            }
        }
       }
            }

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.*;

public class  gym{
    public static void main(String[] args) throws IOException{
        MScanner sc = new MScanner(System.in);
        PrintWriter pw=new PrintWriter(System.out);
        int n=sc.nextInt();
        char[]in=sc.nextLine().toCharArray();
        int z=0;int o=0;
        for(int i=0;i<n;i++) {
        	if(in[i]=='0') {
        		z++;
        	}
        	else {
        		o++;
        	}
        }
        if(z==o) {
        	pw.println(2);
        	pw.print(in[0]+" ");
        	for(int i=1;i<n;i++)pw.print(in[i]);
        }
        else {
        	pw.println(1);
        	for(int i=0;i<n;i++) {
        		pw.print(in[i]);
        	}
        }
        pw.flush();
    }
    static class Vector {

    	double x, y;

    	Vector(double a, double b) { x = a; y = b; }

    	Vector(Point a, Point b) { this(b.x - a.x, b.y - a.y); }

    	Vector scale(double s) { return new Vector(x * s, y * s); }              //s is a non-negative value

    	double dot(Vector v) { return (x * v.x + y * v.y); }

    	double cross(Vector v) { return x * v.y - y * v.x; }

    	double norm2() { return x * x + y * y; }

    	Vector reverse() { return new Vector(-x, -y); }

    	Vector normalize()
    	{
    		double d = Math.sqrt(norm2());
    		return scale(1 / d);
    	}
    }
    static class Point implements Comparable<Point>{

    	static final double EPS = 1e-9;

    	double x, y;

    	Point(double a, double b) { x = a; y = b; }

    	public int compareTo(Point p)
    	{
    		if(Math.abs(x - p.x) > EPS) return x > p.x ? 1 : -1;
    		if(Math.abs(y - p.y) > EPS) return y > p.y ? 1 : -1;
    		return 0;
    	}
    	public String toString() {
    		return "("+x+" "+y+")";
    	}
    	public double dist(Point p) { return sq(x - p.x) + sq(y - p.y); }

    	static double sq(double x) { return x * x; }

    	Point rotate(double angle)
    	{
    		double c = Math.cos(angle), s = Math.sin(angle);
    		return new Point(x * c - y * s, x * s + y * c);
    	}
    	// for integer points and rotation by 90 (counterclockwise) : swap x and y, negate x

    	Point rotate(double theta, Point p)			//rotate around p
    	{
    		Vector v = new Vector(p, new Point(0, 0));
    		return translate(v).rotate(theta).translate(v.reverse());
    	}

    	Point translate(Vector v) { return new Point(x + v.x , y + v.y); }

    	Point reflectionPoint(Line l) 	//reflection point of p on line l
    	{
    		Point p = l.closestPoint(this);
    		Vector v = new Vector(this, p);
    		return this.translate(v).translate(v);
    	}

    	boolean between(Point p, Point q)
    	{
    		return x < Math.max(p.x, q.x) + EPS && x + EPS > Math.min(p.x, q.x)
    				&& y < Math.max(p.y, q.y) + EPS && y + EPS > Math.min(p.y, q.y);
    	}

    	//returns true if it is on the line defined by a and b
    	boolean onLine(Point a, Point b)
    	{
    		if(a.compareTo(b) == 0) return compareTo(a) == 0;
    		return Math.abs(new Vector(a, b).cross(new Vector(a, this))) < EPS;
    	}

    	boolean onSegment(Point a, Point b)
    	{
    		if(a.compareTo(b) == 0) return compareTo(a) == 0;
    		return onRay(a, b) && onRay(b, a);
    	}

    	//returns true if it is on the ray whose start point is a and passes through b
    	boolean onRay(Point a, Point b)
    	{
    		if(a.compareTo(b) == 0) return compareTo(a) == 0;
    		return new Vector(a, b).normalize().equals(new Vector(a, this).normalize());	//implement equals()
    	}

    	// returns true if it is on the left side of Line pq
    	// add EPS to LHS if on-line points are accepted
    	static boolean ccw(Point p, Point q, Point r)
    	{
    		return new Vector(p, q).cross(new Vector(p, r)) > 0;
    	}

    	static boolean collinear(Point p, Point q, Point r)
    	{
    		return Math.abs(new Vector(p, q).cross(new Vector(p, r))) < EPS;
    	}

    	static double angle(Point a, Point o, Point b)  // angle AOB
    	{
    		Vector oa = new Vector(o, a), ob = new Vector(o, b);
    		return Math.acos(oa.dot(ob) / Math.sqrt(oa.norm2() * ob.norm2()));
    	}

    	static double distToLine(Point p, Point a, Point b) //distance between point p and a line defined by points a, b (a != b)
    	{
    		if(a.compareTo(b) == 0) return p.dist(a);
    		// formula: c = a + u * ab
    		Vector ap = new Vector(a, p), ab = new Vector(a, b);
    		double u = ap.dot(ab) / ab.norm2();
    		Point c = a.translate(ab.scale(u));
    		return p.dist(c);
    	}
    	// Another way: find closest point and calculate the distance between it and p

    	static double distToLineSegment(Point p, Point a, Point b)
    	{
    		Vector ap = new Vector(a, p), ab = new Vector(a, b);
    		double u = ap.dot(ab) / ab.norm2();
    		if (u < 0.0) return p.dist(a);
    		if (u > 1.0) return p.dist(b);
    		return distToLine(p, a, b);
    	}
    	// Another way: find closest point and calculate the distance between it and p
    }
    static class Line {

    	static final double INF = 1e9, EPS = 1e-9;

    	double a, b, c;

    	Line(Point p, Point q)
    	{
    		if(Math.abs(p.x - q.x) < EPS) {	a = 1; b = 0; c = -p.x;	}
    		else
    		{
    			a = (p.y - q.y) / (q.x - p.x);
    			b = 1.0;
    			c = -(a * p.x + p.y);
    		}

    	}

    	Line(Point p, double m) { a = -m; b = 1; c =  -(a * p.x + p.y); }

    	boolean parallel(Line l) { return Math.abs(a - l.a) < EPS && Math.abs(b - l.b) < EPS; }

    	boolean same(Line l) { return parallel(l) && Math.abs(c - l.c) < EPS; }

    	Point intersect(Line l)
    	{
    		if(parallel(l))
    			return null;
    		double x = (b * l.c - c * l.b) / (a * l.b - b * l.a);
    		double y;
    		if(Math.abs(b) < EPS)
    			 y = -l.a * x - l.c;
    		else
    			y = -a * x - c;

    		return new Point(x, y);
    	}

    	Point closestPoint(Point p)
    	{
    		if(Math.abs(b) < EPS) return new Point(-c, p.y);
    		if(Math.abs(a) < EPS) return new Point(p.x, -c);
    		return intersect(new Line(p, 1 / a));
    	}

    }
    static long gcd(long a, long b) {

		if (b == 0)
			return a;
		return gcd(b, a % b);
	}
    static int[]primes;
    static int sizeofp=0;
	static int[] isComposite;

	static void sieve(int N)	// O(N log log N)
	{
		isComposite = new int[N+1];
		isComposite[0] = isComposite[1] = 1;
		primes = new int[N];

		for (int i = 2; i <= N; ++i)
			if (isComposite[i] == 0)
			{
				primes[sizeofp++]=i;;
				if(1l * i * i <= N)
					for (int j = i * i; j <= N; j += i)
						isComposite[j] = 1;
			}
	}
    static class pair implements Comparable<pair>{
    	int num;int idx;int s;
    	pair(int x,int y,int o){
    		num=x;idx=y;s=o;
    	}
		@Override
		public int compareTo(pair o) {
			if(num!=o.num) {
				return num-o.num;
			}
			return idx-o.idx;
		}
		public boolean equals(pair o) {
			if(this.compareTo(o)==0)return true;
			return false;
		}
		public String toString() {
			return "("+0+" "+0+")";
		}
    }
	static class MScanner
	{
	    StringTokenizer st;
	    BufferedReader br;

	    public MScanner(InputStream s){    br = new BufferedReader(new InputStreamReader(s));}

	    public String next() throws IOException
	    {
	        while (st == null || !st.hasMoreTokens())
	            st = new StringTokenizer(br.readLine());
	        return st.nextToken();
	    }

	    public int nextInt() throws IOException {return Integer.parseInt(next());}

	    public long nextLong() throws IOException {return Long.parseLong(next());}

	    public String nextLine() throws IOException {return br.readLine();}

	    public double nextDouble() throws IOException
	    {
	        String x = next();
	        StringBuilder sb = new StringBuilder("0");
	        double res = 0, f = 1;
	        boolean dec = false, neg = false;
	        int start = 0;
	        if(x.charAt(0) == '-')
	        {
	            neg = true;
	            start++;
	        }
	        for(int i = start; i < x.length(); i++)
	            if(x.charAt(i) == '.')
	            {
	                res = Long.parseLong(sb.toString());
	                sb = new StringBuilder("0");
	                dec = true;
	            }
	            else
	            {
	                sb.append(x.charAt(i));
	                if(dec)
	                    f *= 10;
	            }
	        res += Long.parseLong(sb.toString()) / f;
	        return res * (neg?-1:1);
	    }

	    public boolean ready() throws IOException {return br.ready();}

	}
}

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

public class code {

	/**
	 * @param args
	 */
	public static PrintWriter out = new PrintWriter(System.out);

	public static void main(String[] args) throws Exception
	{
		// TODO Auto-generated method stub

		 BufferedReader br=new BufferedReader(new InputStreamReader(System.in));

	        	int n = Integer.parseInt(br.readLine());
	        	String s = br.readLine().trim();

	        	char[]a = s.toCharArray();
	        	if(n%2!=0)
	        	{
	        		out.println("1");
	        		out.println(new String(a));
	        	}
	        	else
	        	{
	        		int z,o;
	        		z=0;
	        		o=0;

	        		for(int i=0;i<a.length;i++)
	        		{
	        			if(a[i]=='0')
	        				z++;
	        			else
	        				o++;

	        		}
	        		if(z!=o)
	        		{
	        			out.println("1");
	        			out.println(s);
	        		}
	        		else
	        		{
	        			z=0;o=0;
	        		for(int i=0;i<a.length;i++)
	        		{
	        			if(a[i]=='0')
	        				z++;
	        			else
	        				o++;

	        			if((z+o)%2!=0)
	        			{
	        				out.println("2");
	        				out.print(s.substring(0,i+1)+" "+s.substring(i+1,a.length));
	        				break;
	        			}
	        		}

	        	}
	        	}

	        out.close();
	}

}

import java.io.*;

public class test{
    public static void main(String[] args) {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        try {
            int n = Integer.parseInt(br.readLine());
            String s = br.readLine();
            if(n%2==0) {
                int tot=0;
                for(char c : s.toCharArray()) {
                    if(c=='1') tot+=1;
                    else tot-=1;
                }
                if(tot==0) {
                    System.out.println(2);
                    System.out.println(s.substring(0,s.length()-1) + " " + s.substring(s.length()-1));
                }else {
                    System.out.println(1);
                    System.out.println(s);
                }
            }else {
                System.out.println(1);
                System.out.println(s);
            }
            return;
        } catch (Exception e) {
            return;
        }
    }
}

import java.util.Scanner;
public class Code {
        public static void main(String[] args) {
            Scanner input = new Scanner(System.in);
            int n = input.nextInt();
            int z = 0, a = 0;
            String s = input.next();
            for (int i = 0; i < s.length(); i++) {
                if (s.charAt(i) == '0') z++;
                else a++;
            }
            if (z != a) {
                System.out.println(1 + "\n" + s);
            } else System.out.println(2 + "\n" + s.charAt(0) + " " + s.substring(1));
        }
}

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

 public class Param
{

      public static  void main( String[]args)
    {
  	Scanner param=new Scanner (System.in);
  	int end=param.nextInt();
  	String a=param.next();

  	char arr[]=new char[end];
  	for(int i=0;i<end;i++){
  	   arr[i]=a.charAt(i);
  	}
  	int count=0;
  	int check=0;
  	ArrayList<Character>l1=new ArrayList<Character>();
  for(int i=0;i<arr.length;i++){
     if(arr[i]=='1'){
        count++;
     }
     else{
        check++;
     }
  }
  String r="";
  if(count!=check){
     System.out.println(1);
     System.out.println(a);
  }
  else{
     for(int i=0;i<arr.length-1;i++){
        r+=arr[i];
     }
    if(a.length()==1){
  	   System.out.println(1);
  	}
  	else{
  	   System.out.println(2);
  	}
     System.out.print(r+" ");
     System.out.println(arr[end-1]);
  }

}
}

import java.io.*;
import java.math.BigInteger;
import java.math.RoundingMode;
import java.security.KeyStore.Entry;
import java.text.DecimalFormat;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import javax.net.ssl.SSLContext;

public class Main
{
   static long mod=(long)(1e+9 + 7);
   static int[] sieve;
   static ArrayList<Integer> primes;
   static int[] visited;

   static class Pair
   {
	   long l;
	   long r;

	   public Pair(long x,long y)
	   {
		   this.l=x;
		   this.r=y;
	   }
   }

   public static void main(String[] args) throws java.lang.Exception
   {
	     fast s = new fast();
	     PrintWriter out=new PrintWriter(System.out);
	     Scanner sc=new Scanner(System.in);
	     StringBuilder fans = new StringBuilder();

	     int n=s.nextInt();

	     String str=s.nextLine();
	     int z=0;
	     int o=0;

	     String ans1="";
	     String ans2="";

	     for(int i=0;i<str.length();i++)
	    	 if(str.charAt(i)=='0') z++;
	    	 else o++;

	     int cur_z=0;
	     int cur_o=0;

	     int temp1=z;
	     int temp2=o;

	     List<String> ans=new ArrayList<String>();
	     int k=0;
	     for(int i=0;i<str.length();i++)
	    	 {
	    		if(str.charAt(i)=='0')
	    			cur_z++;
	    		else
	    			cur_o++;

	    		if(cur_z!=cur_o && (z-cur_z)!=(o-cur_o))
	    			{
	    				ans.add(str.substring(0, i+1));
	    				ans.add(str.substring(i+1,str.length()));
	    				break;
	    			}
	    	 }

	     if(n==1 || temp1!=temp2)
	    	 {
	    	 System.out.println("1");
	    	 System.out.println(str);}
	     else
	    	 {
	    		 System.out.println(ans.size());

	    		 for(String str1:ans)
	    			 System.out.print(str1+" ");
	    	 }
   }

static class fast {
	private InputStream i;
		private byte[]  buf = new byte[1024];
		private int curChar;
		private int numChars;

		//Return floor log2n
		public static long log2(long bits) // returns 0 for bits=0
			{
			    int log = 0;
			    if( ( bits & 0xffff0000 ) != 0 ) { bits >>>= 16; log = 16; }
			    if( bits >= 256 ) { bits >>>= 8; log += 8; }
			    if( bits >= 16  ) { bits >>>= 4; log += 4; }
			    if( bits >= 4   ) { bits >>>= 2; log += 2; }
			    return log + ( bits >>> 1 );
			}

		public static boolean next_permutation(int a[])
		   {
			   int i=0,j=0;int index=-1;
			   int n=a.length;

			   for(i=0;i<n-1;i++)
				   if(a[i]<a[i+1]) index=i;

			   if(index==-1) return false;
			   i=index;

			   for(j=i+1;j<n && a[i]<a[j];j++);

			   int temp=a[i];
			   a[i]=a[j-1];
			   a[j-1]=temp;

			   for(int p=i+1,q=n-1;p<q;p++,q--)
			   {
				   temp=a[p];
				   a[p]=a[q];
				   a[q]=temp;
			   }

			   return true;
		   }

		public static void division(char ch[],int divisor)
		   {
			   int div=Character.getNumericValue(ch[0]); int mul=10;int remainder=0;
			   StringBuilder quotient=new StringBuilder("");
			   for(int i=1;i<ch.length;i++)
			   {
				   div=div*mul+Character.getNumericValue(ch[i]);
				   if(div<divisor) {quotient.append("0");continue;}
				   quotient.append(div/divisor);
				   div=div%divisor;mul=10;

			   }
			   remainder=div;
			   while(quotient.charAt(0)=='0')quotient.deleteCharAt(0);
			   System.out.println(quotient+" "+remainder);
		   }

		public static void sieve(int size)
		{
			sieve=new int[size+1];

			primes=new ArrayList<Integer>();

			sieve[1]=1;

			for(int i=2;i<=Math.sqrt(size);i++)
			{
				if(sieve[i]==0)
				 {
					for(int j=i*i;j<size;j+=i) {sieve[j]=1;}
				 }
			}

			for(int i=2;i<=size;i++)
			{
				if(sieve[i]==0) primes.add(i);
			}
		}

		public static long pow(long n, long b, long MOD)
		   {
		       long x=1;long y=n;
		       while(b > 0)
		       {
		           if(b%2 == 1)
		           {
		               x=x*y;
		               if(x>MOD) x=x%(MOD);
		           }
		           y = y*y;
		           if(y>MOD) y=y%(MOD);
		           b >>= 1;
		       }
		       return x;
		   }

		public static long mod_inv(long n,long mod)
		{
			return pow(n,mod-2,mod);
		}

		//Returns index of highest number less than or equal to key
		 public static int upper(long[] a,int length,long key)
		 {
			    int low = 0;
		        int high = length-1;
		        int ans=-1;

		        while (low <= high) {
		            int mid = (low + high) / 2;
		            if (key >= a[mid]) {
		                ans=mid;
		            	low = mid+1;
		            } else if(a[mid]>key){
		                high = mid - 1;
		            }
		        }
		        return ans;
		}

		//Returns index of least number greater than or equal to key
		 public static int lower(long[] a,int length,long key)
		 {
			    int low = 0;
		        int high = length-1;
		        int ans=-1;

		        while (low <= high) {
		            int mid = (low + high) / 2;
		            if (key<=a[mid]) {
		                ans=mid;
		            	high = mid-1;
		            }
		            else{
		            		low=mid+1;
		            	}
		        }
		        return ans;
		}

		public long gcd(long r,long ans)
		{
			if(r==0) return ans;
			return gcd(ans%r,r);
		}
		public fast() {
			this(System.in);
		}
		public fast(InputStream is) {
			i = is;
		}
		public int read() {
			if (numChars == -1)
				throw new InputMismatchException();
			if (curChar >= numChars) {
				curChar = 0;
				try {
					numChars = i.read(buf);
				} catch (IOException e) {
					throw new InputMismatchException();
				}
				if (numChars <= 0)
					return -1;
			}
			return buf[curChar++];
		}
		public String nextLine() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			StringBuilder res = new StringBuilder();
			do {
				res.appendCodePoint(c);
				c = read();
			} while (!isEndOfLine(c));
			return res.toString();
		}
		public String nextString() {
     		int c = read();
			while (isSpaceChar(c))
				c = read();
			StringBuilder res = new StringBuilder();
			do {
				res.appendCodePoint(c);
				c = read();
			} while (!isSpaceChar(c));
			return res.toString();
		}
		public long nextLong() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = read();
			}
			long res = 0;
			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			} while (!isSpaceChar(c));
			return res * sgn;
		}
		public int nextInt() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = read();
			}
			int res = 0;
			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			} while (!isSpaceChar(c));
			return res * sgn;
		}
		public boolean isSpaceChar(int c) {
			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
		}
		public boolean isEndOfLine(int c) {
			return c == '\n' || c == '\r' || c == -1;
		}

	}
}

import java.util.*;
import java.io.*;
import java.math.*;
public class A572{

	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;
		}
	}

	static class pair{
		int first,second;
		pair(int f,int s){
			first=f;
			second=s;
		}
	}

	public static long fastexpo(long x, long y, long p){
		long res=1;
		while(y > 0){
			if((y & 1)==1)
				res= ((res%p)*(x%p))%p;
			y= y >> 1;
			x = ((x%p)*(x%p))%p;
		}
		return res;
	}

	public static boolean[] sieve (int n) {
		boolean primes[]=new boolean[n+1];
		Arrays.fill(primes,true);
		primes[0]=primes[1]=false;
		for(int i=2;i*i<=n;i++){
			if(primes[i]){
				for(int j=i*i;j<=n;j+=i)
					primes[j]=false;
			}
		}
		return primes;
	}

	public static long gcd(long a,long b){
        return (BigInteger.valueOf(a).gcd(BigInteger.valueOf(b))).longValue();
    }

    public static void merge(int a[],int l,int m,int r){
        int n1,n2,i,j,k;
        n1=m-l+1;
        n2=r-m;

        int L[]=new int[n1];
        int R[]=new int[n2];

        for(i=0;i<n1;i++)
            L[i]=a[l+i];
        for(j=0;j<n2;j++)
            R[j]=a[m+1+j];

        i=0;j=0;

        k=l;
        while(i<n1&&j<n2){
            if(L[i]<=R[j]){
                a[k]=L[i];
                i++;
            }
            else{
                a[k]=R[j];
                j++;
            }
            k++;
        }

        while(i<n1){
            a[k]=L[i];
            i++;
            k++;
        }
        while(j<n2){
            a[k]=R[j];
            j++;
            k++;
        }
    }
    public static void sort(int a[],int l,int r){
        int m;
        if(l<r){
            m=(l+r)/2;
            sort(a,l,m);
            sort(a,m+1,r);

            merge(a,l,m,r);
        }
    }

	public static void main(String args[]){
		FastReader sc = new FastReader();
		int n,i,one,zero;
		String s;
		n=sc.nextInt();
		s=sc.next();
		one=0;zero=0;
		for(i=0;i<n;i++){
			if(s.charAt(i)=='0')
				zero++;
			else
				one++;
		}
		if(n%2==1||one!=zero){
			System.out.println(1);
			System.out.println(s);
			System.exit(0);
		}
		System.out.println(2);
		if((n/2)%2==0){
			System.out.print(s.substring(0,(n/2)+1)+" ");
			System.out.println(s.substring((n/2)+1));
		}
		else if((n/2)%2==1){
			System.out.print(s.substring(0,n/2)+" ");
			System.out.println(s.substring(n/2));
		}

	}
}

import java.util.Scanner;
import java.util.Vector;

public class Prince77 {

	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);

		int n = input.nextInt();
		char[] ch = input.next().toCharArray();
		int o = 0, z = 0;
		for ( int i = 0; i < n; i++ ) {
			if ( ch[i] == '0' ) z++;
			else o++;
		}

		if ( z != o ) {
			System.out.println(1);
			System.out.println(ch);
		} else {
			System.out.println(2);
			for ( int i = 0; i < n-1; i++ )
				System.out.print(ch[i]);
			System.out.println(" " + ch[n-1]);
		}
	}

}

import java.io.*;
import java.util.*;
public class KeanuReeves
{
public static void main(String[] f)
{
	int N,i,bit0=0,bit1=0;
	String S;
	char ch[];
	Scanner sc=new Scanner(System.in);
	N=sc.nextInt();
	S=sc.next();
	ch=S.toCharArray();
	for(i=0;i<N;i++)
	{
		if(ch[i]=='1')
		{
			bit1++;
		}
		if(ch[i]=='0')
			bit0++;
	}
	if((N%2!=0) || (bit0!=bit1))
	{
		System.out.println("1");
		System.out.print(S);
	}
	else if((N/2)%2!=0)
	{
		System.out.println("2");
		System.out.print(new String(S.substring(0,N/2))+" ");
		System.out.print(new String(S.substring(N/2,N))+" ");
	}
	else
	{
		System.out.println("2");
		System.out.print(new String(S.substring(0,(N/2+1)))+" ");
		System.out.print(new String(S.substring((N/2+1),N))+" ");
	}
}
}

import java.util.Scanner;

public class Main{
public static void main(String[] args){
    Scanner sc=new Scanner(System.in);

     int n=sc.nextInt();
        String s=sc.next();
        int num0=0;
        int num1=0;
        for(int i=0;i<n;i++)
        {
            char chr1=s.charAt(i);
            if(chr1=='0')
            {
                num0++;
            }
            else
            {
                num1++;
            }
        }
        if(num0==num1)
        {
            System.out.print(2+"\n");
            System.out.print(s.substring(0,n-1)+" "+s.substring(n-1)+"");
        }
        else
        {
            System.out.print(1+"\n");
            System.out.println(s+"");
        }

    }
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Scanner;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author Shahab
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        Scanner in = new Scanner(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskA solver = new TaskA();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskA {
        public void solve(int testNumber, Scanner in, PrintWriter out) {
            int n = in.nextInt();
            String s = in.next();

            if (isGood(s)) {
                out.println("1");
                out.println(s);
            } else {
                out.println("2");
                out.print(s.substring(0, s.length() - 1));
                out.print(" ");
                out.println(s.charAt(s.length() - 1));
            }
        }

        private boolean isGood(String s) {
            int cnt1 = 0;
            int cnt0 = 0;

            for (int i = 0; i < s.length(); i++) {
                if (s.charAt(i) == '1') cnt1++;
                else cnt0++;
            }

            return cnt0 != cnt1;
        }

    }
}

import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.StringTokenizer;

public class cf {
	public static class FastReader {
		BufferedReader br;
		StringTokenizer st;
		//it reads the data about the specified point and divide the data about it ,it is quite fast
		//than using direct

		public FastReader() {
			br = new BufferedReader(new InputStreamReader(System.in));
		}

		String next() {
			while (st == null || !st.hasMoreTokens()) {
				try {
					st = new StringTokenizer(br.readLine());
				} catch (Exception r) {
					r.printStackTrace();
				}
			}
			return st.nextToken();
		}

		int nextInt() {
			return Integer.parseInt(next());//converts string to integer
		}

		double nextDouble() {
			return Double.parseDouble(next());
		}

		long nextLong() {
			return Long.parseLong(next());
		}

		String nextLine() {
			String str = "";
			try {
				str = br.readLine();
			} catch (Exception r) {
				r.printStackTrace();
			}
			return str;
		}
	}
	static int sum(int n)
	{int s=0;
		while(n!=0)
		{
			s+=n%10;
			n/=10;
		}
		return s;
	}

	public static PrintWriter out = new PrintWriter (new BufferedOutputStream(System.out));
	static class Pair{
        int x;int y;
        Pair(int x,int y){
            this.x=x;
            this.y=y;
          //  this.i=i;
        }
    }
	static int no(String s)
	{
		int one=0;
		for(int i=0;i<s.length();i++)
		{
			if(s.charAt(i)=='1')
				one++;
		}
		return one;
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		HashMap<Integer,Integer>map=new HashMap<Integer,Integer>();
		ArrayList<String>list=new ArrayList<String>();
		FastReader in=new FastReader();
int n=in.nextInt();
String s=in.next();String str="";
int i=1;
while(n!=1)
{int t=0;int y=0;
	String s1=s.substring(i,n);
	String s2=s.substring(0,i);
	if(no(s1)!=(s1.length()-no(s1)))
		t=1;
	if(no(s2)!=(s2.length()-no(s2)))
		y=1;
	if(t==1&&y==1)
		{str=s2+" "+s1;
		break;
		}

}
if(n==1)
{
System.out.println(1);
System.out.println(s);
}
else
{
System.out.println(2);
System.out.println(str);

}

	}

}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.stream.IntStream;
import java.util.Scanner;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author Akash
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        Scanner in = new Scanner(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        AKeanuReeves solver = new AKeanuReeves();
        solver.solve(1, in, out);
        out.close();
    }

    static class AKeanuReeves {
        public void solve(int testNumber, Scanner in, PrintWriter out) {
            int n = in.nextInt();
            String clr = in.nextLine();
            String s = in.nextLine();
            long zeros = s.chars().filter(x -> x == '0').count();
            long ones = n - zeros;
            if (zeros != ones) {
                out.println(s);
            } else {
                while (zeros-- > 0) {
                    out.print(0);
                }
                out.print(" ");
                while (ones-- > 0) {
                    out.print(1);
                }
            }
        }

    }
}

import java.util.Scanner;

public class A {
	public static void main(String... g) {
		Scanner s = new Scanner(System.in);
		int n = s.nextInt();
		String z = s.next();
		for(int i=0;i<z.length();i++) {
			String a = z.substring(0, i);
			String b = z.substring(i);
			if(ok(a) && ok(b)) {
				System.out.println(2);
				System.out.println(a+" "+b);
				return;
			}
		}
		System.out.println(1);
		System.out.println(z);
	}

	static boolean ok(String z) {
		int a = 0, b = 0;
		for(char c : z.toCharArray()) {
			if (c == '0') {
				a++;
			}else {
				b++;
			}
		}
		return a!=b;
	}
}

import java.util.Scanner;
import java.util.HashMap;
import java.util.Scanner;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Queue;
public class Codepractis {

    public static void main(String[] args) {

        Scanner scan=new Scanner(System.in);

        int n = scan.nextInt();
        String str = scan.next();
         String s = "";
         int count1=0;
         int count0=0;
         int cut = 0 ;

           for (int i = 0; i <str.length(); i++) {
             if(str.charAt(i)=='1'){
              s+='1';
              count1++;
             }
             if(str.charAt(i)=='0'){
                 s+='0';
                 count0++;
             }
             if(count0!=count1&&i!=str.length()-1){
                 s+=" ";
                 cut++;
                 count0=0;
                 count1=0;
             }

        }
         if(str.length() == 1){
             System.out.println(1);
             System.out.println(str);
         }
         else if (str.length() ==2){
             System.out.println(2);
             System.out.println(str.charAt(0)+" "+str.charAt(1));
         }

         else{
             System.out.println(cut+1);
             System.out.println(s);
         }
    }

}

import java.util.Scanner;

public class KeanuReeves {
static int n = 0;
static String str = "";
static int counter = 0;

public static void main(String args[]){
Scanner in = new Scanner(System.in);
n = in.nextInt();
str = in.next();
StringBuffer sb = new StringBuffer("");
// case It is good
if (count ('1',str) != count ('0',str) ){
   //System.out.println("1 "+count ('1',str));
   //System.out.println("0 "+count ('0',str));
System.out.println(1);
for (int i = 0;i < str.length();i++){
System.out.print(str.charAt(i));
}
}else if (n ==2){
System.out.println(n);
System.out.print(str.charAt(0) +" " + str.charAt(1));
}
else {
 // case It is not good
System.out.println(n/3);
for (int i = 0; i < str.length();i++){
  if (i == str.length() - 1){
System.out.print(sb.append(str.charAt(i)));}
else if (count('1',sb.toString()) != count('0',sb.toString()) && sb.length() > 2 ){
System.out.print(sb+" ");
sb.delete(0,sb.length()-1);

}else {sb.append(str.charAt(i));}

}

}
}

public static int count(char ch,String s){
 int c = 0;
for (int i = 0 ; i < s.length();i++){
if (s.charAt(i) == ch){
//System.out.println("c "+c);
c+=1;
}}
return c;

}
}

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
Scanner scan=new Scanner(System.in);
List w=new ArrayList();
List ww=new ArrayList();
int n=scan.nextInt();
String s=scan.next();
if(n==1){
    System.out.println('1');
     System.out.println(s);
    System.exit(0);
}
if(n==2){
    System.out.println('2');
    System.out.println(s.charAt(0)+" "+s.charAt(1));
        System.exit(0);
}
    char a=s.charAt(0);
for(int i=0;i<n;i++){
 if(s.charAt(i)==a)
    w.add(s.charAt(i));
else if(s.charAt(i)!=a)
    ww.add(s.charAt(i));
 if(w.size()!=ww.size()&&(w.size()>=2||ww.size()>=2))
{System.out.println(s.subSequence(0, i+1)+" "+s.subSequence(i+1, n));
break;
}
}
}
    }

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.*;

public class  gym{
    public static void main(String[] args) throws IOException{
        MScanner sc = new MScanner(System.in);
        PrintWriter pw=new PrintWriter(System.out);
        int n=sc.nextInt();
        char[]in=sc.nextLine().toCharArray();
        int z=0;int o=0;
        for(int i=0;i<n;i++) {
        	if(in[i]=='0') {
        		z++;
        	}
        	else {
        		o++;
        	}
        }
        if(z+o==n && o!=0 && z!=0) {
        	pw.println(2);
        	pw.print(in[0]);
        	pw.print(" ");
        	for(int i=1;i<n;i++)pw.print(in[i]);
        }
        else {
        	pw.println(1);
        	for(int i=0;i<n;i++) {
        		pw.print(in[i]);
        	}
        }
        pw.flush();
    }
    static class Vector {

    	double x, y;

    	Vector(double a, double b) { x = a; y = b; }

    	Vector(Point a, Point b) { this(b.x - a.x, b.y - a.y); }

    	Vector scale(double s) { return new Vector(x * s, y * s); }              //s is a non-negative value

    	double dot(Vector v) { return (x * v.x + y * v.y); }

    	double cross(Vector v) { return x * v.y - y * v.x; }

    	double norm2() { return x * x + y * y; }

    	Vector reverse() { return new Vector(-x, -y); }

    	Vector normalize()
    	{
    		double d = Math.sqrt(norm2());
    		return scale(1 / d);
    	}
    }
    static class Point implements Comparable<Point>{

    	static final double EPS = 1e-9;

    	double x, y;

    	Point(double a, double b) { x = a; y = b; }

    	public int compareTo(Point p)
    	{
    		if(Math.abs(x - p.x) > EPS) return x > p.x ? 1 : -1;
    		if(Math.abs(y - p.y) > EPS) return y > p.y ? 1 : -1;
    		return 0;
    	}
    	public String toString() {
    		return "("+x+" "+y+")";
    	}
    	public double dist(Point p) { return sq(x - p.x) + sq(y - p.y); }

    	static double sq(double x) { return x * x; }

    	Point rotate(double angle)
    	{
    		double c = Math.cos(angle), s = Math.sin(angle);
    		return new Point(x * c - y * s, x * s + y * c);
    	}
    	// for integer points and rotation by 90 (counterclockwise) : swap x and y, negate x

    	Point rotate(double theta, Point p)			//rotate around p
    	{
    		Vector v = new Vector(p, new Point(0, 0));
    		return translate(v).rotate(theta).translate(v.reverse());
    	}

    	Point translate(Vector v) { return new Point(x + v.x , y + v.y); }

    	Point reflectionPoint(Line l) 	//reflection point of p on line l
    	{
    		Point p = l.closestPoint(this);
    		Vector v = new Vector(this, p);
    		return this.translate(v).translate(v);
    	}

    	boolean between(Point p, Point q)
    	{
    		return x < Math.max(p.x, q.x) + EPS && x + EPS > Math.min(p.x, q.x)
    				&& y < Math.max(p.y, q.y) + EPS && y + EPS > Math.min(p.y, q.y);
    	}

    	//returns true if it is on the line defined by a and b
    	boolean onLine(Point a, Point b)
    	{
    		if(a.compareTo(b) == 0) return compareTo(a) == 0;
    		return Math.abs(new Vector(a, b).cross(new Vector(a, this))) < EPS;
    	}

    	boolean onSegment(Point a, Point b)
    	{
    		if(a.compareTo(b) == 0) return compareTo(a) == 0;
    		return onRay(a, b) && onRay(b, a);
    	}

    	//returns true if it is on the ray whose start point is a and passes through b
    	boolean onRay(Point a, Point b)
    	{
    		if(a.compareTo(b) == 0) return compareTo(a) == 0;
    		return new Vector(a, b).normalize().equals(new Vector(a, this).normalize());	//implement equals()
    	}

    	// returns true if it is on the left side of Line pq
    	// add EPS to LHS if on-line points are accepted
    	static boolean ccw(Point p, Point q, Point r)
    	{
    		return new Vector(p, q).cross(new Vector(p, r)) > 0;
    	}

    	static boolean collinear(Point p, Point q, Point r)
    	{
    		return Math.abs(new Vector(p, q).cross(new Vector(p, r))) < EPS;
    	}

    	static double angle(Point a, Point o, Point b)  // angle AOB
    	{
    		Vector oa = new Vector(o, a), ob = new Vector(o, b);
    		return Math.acos(oa.dot(ob) / Math.sqrt(oa.norm2() * ob.norm2()));
    	}

    	static double distToLine(Point p, Point a, Point b) //distance between point p and a line defined by points a, b (a != b)
    	{
    		if(a.compareTo(b) == 0) return p.dist(a);
    		// formula: c = a + u * ab
    		Vector ap = new Vector(a, p), ab = new Vector(a, b);
    		double u = ap.dot(ab) / ab.norm2();
    		Point c = a.translate(ab.scale(u));
    		return p.dist(c);
    	}
    	// Another way: find closest point and calculate the distance between it and p

    	static double distToLineSegment(Point p, Point a, Point b)
    	{
    		Vector ap = new Vector(a, p), ab = new Vector(a, b);
    		double u = ap.dot(ab) / ab.norm2();
    		if (u < 0.0) return p.dist(a);
    		if (u > 1.0) return p.dist(b);
    		return distToLine(p, a, b);
    	}
    	// Another way: find closest point and calculate the distance between it and p
    }
    static class Line {

    	static final double INF = 1e9, EPS = 1e-9;

    	double a, b, c;

    	Line(Point p, Point q)
    	{
    		if(Math.abs(p.x - q.x) < EPS) {	a = 1; b = 0; c = -p.x;	}
    		else
    		{
    			a = (p.y - q.y) / (q.x - p.x);
    			b = 1.0;
    			c = -(a * p.x + p.y);
    		}

    	}

    	Line(Point p, double m) { a = -m; b = 1; c =  -(a * p.x + p.y); }

    	boolean parallel(Line l) { return Math.abs(a - l.a) < EPS && Math.abs(b - l.b) < EPS; }

    	boolean same(Line l) { return parallel(l) && Math.abs(c - l.c) < EPS; }

    	Point intersect(Line l)
    	{
    		if(parallel(l))
    			return null;
    		double x = (b * l.c - c * l.b) / (a * l.b - b * l.a);
    		double y;
    		if(Math.abs(b) < EPS)
    			 y = -l.a * x - l.c;
    		else
    			y = -a * x - c;

    		return new Point(x, y);
    	}

    	Point closestPoint(Point p)
    	{
    		if(Math.abs(b) < EPS) return new Point(-c, p.y);
    		if(Math.abs(a) < EPS) return new Point(p.x, -c);
    		return intersect(new Line(p, 1 / a));
    	}

    }
    static long gcd(long a, long b) {

		if (b == 0)
			return a;
		return gcd(b, a % b);
	}
    static int[]primes;
    static int sizeofp=0;
	static int[] isComposite;

	static void sieve(int N)	// O(N log log N)
	{
		isComposite = new int[N+1];
		isComposite[0] = isComposite[1] = 1;
		primes = new int[N];

		for (int i = 2; i <= N; ++i)
			if (isComposite[i] == 0)
			{
				primes[sizeofp++]=i;;
				if(1l * i * i <= N)
					for (int j = i * i; j <= N; j += i)
						isComposite[j] = 1;
			}
	}
    static class pair implements Comparable<pair>{
    	int num;int idx;int s;
    	pair(int x,int y,int o){
    		num=x;idx=y;s=o;
    	}
		@Override
		public int compareTo(pair o) {
			if(num!=o.num) {
				return num-o.num;
			}
			return idx-o.idx;
		}
		public boolean equals(pair o) {
			if(this.compareTo(o)==0)return true;
			return false;
		}
		public String toString() {
			return "("+0+" "+0+")";
		}
    }
	static class MScanner
	{
	    StringTokenizer st;
	    BufferedReader br;

	    public MScanner(InputStream s){    br = new BufferedReader(new InputStreamReader(s));}

	    public String next() throws IOException
	    {
	        while (st == null || !st.hasMoreTokens())
	            st = new StringTokenizer(br.readLine());
	        return st.nextToken();
	    }

	    public int nextInt() throws IOException {return Integer.parseInt(next());}

	    public long nextLong() throws IOException {return Long.parseLong(next());}

	    public String nextLine() throws IOException {return br.readLine();}

	    public double nextDouble() throws IOException
	    {
	        String x = next();
	        StringBuilder sb = new StringBuilder("0");
	        double res = 0, f = 1;
	        boolean dec = false, neg = false;
	        int start = 0;
	        if(x.charAt(0) == '-')
	        {
	            neg = true;
	            start++;
	        }
	        for(int i = start; i < x.length(); i++)
	            if(x.charAt(i) == '.')
	            {
	                res = Long.parseLong(sb.toString());
	                sb = new StringBuilder("0");
	                dec = true;
	            }
	            else
	            {
	                sb.append(x.charAt(i));
	                if(dec)
	                    f *= 10;
	            }
	        res += Long.parseLong(sb.toString()) / f;
	        return res * (neg?-1:1);
	    }

	    public boolean ready() throws IOException {return br.ready();}

	}
}

import java.util.Scanner;

public class Main {

	public static void main(String[] args)
	{
		Scanner s=new Scanner(System.in);

		int n=s.nextInt();

		String str=s.next();

		int[] zero=new int[n];
		int[] one=new int[n];

		for(int i=0;i<n;i++)
		{
			if(str.charAt(i)=='0')
			{
				if(i==0)
				{
					zero[i]=1;
				}
				else
				{
					zero[i]=zero[i-1]+1;
				}
			}
			else
			{
				if(i==0)
				{
					one[i]=1;
				}
				else
				{
					one[i]=one[i-1]+1;
				}
			}
		}

		int index=-1;

		for(int j=n-1;j>=0;j--)
		{
			if(zero[j]!=one[j]&&zero[n-1]-zero[j]!=one[n-1]-one[j])
			{
				index=j;
				break;
			}
		}

		if(n==1)
		{
			System.out.println(1);
			System.out.println(str);
		}
		else if(zero[n-1]!=one[n-1])
		{
			System.out.println(1);
			System.out.println(str);
		}
		else
		{
			System.out.println(2);
			System.out.println(str.substring(0,index+1)+" "+str.substring(index+1));
		}

	}

}

import java.util.Scanner;
public class KeanuReeves {

    public static void main(String[] args) {
    Scanner s = new Scanner (System.in);
    int num = s.nextInt();
    String n = s.next();
    if (num == n.length()){
    int countZ = 0 , countO = 0 ;
    if (n.length() == 1)
        System.out.println(n);
    else{
    for (int i = 0 ; i < n.length() ; i++)
        if ((int)n.charAt(i) == 1)
            countO++;
        else
            countZ++;
    if (countO == countZ)
        System.out.println("n");
    else
        System.out.println(n.substring(0,n.length()/2) +" "+n.substring(n.length()/2,n.length()));
    }
    }
    }
}

import java.util.*;

public class A_sol{
    public static void main(String args[]){
        Scanner sn = new Scanner(System.in);
        int n = sn.nextInt();
        sn.nextLine();
        String input = sn.nextLine();
        char [] arr = input.toCharArray();
        int one=0, zero=0;
        for(int i=0; i<n; i++){
            if(arr[i]=='0') zero++;
            else one++;
        }
        if(one!=zero){
            System.out.println(input);
            return;
        }
        System.out.print(input.substring(0,n-1));
        System.out.print(" ");
        System.out.print(arr[n-1]);
    }
}

import java.util.*;
import java.io.*;
public class Div2_572_Virtual {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) {
        FastReader fs = new FastReader();

        String inp = fs.next();
        int n = inp.length();
        int co1 = 0 ; int co2 = 0 ;
        int zero[] = new int[n];
        int one[] = new int[n];
        for(int i=0 ; i<n ; i++){
            if(inp.charAt(i)=='0'){
                co1++;
            }else{
                co2++;
            }
            zero[i]=co1;
            one[i]=co2;
        }
        int brk = 0 ;
        for(int i= n-1 ; i>=0 ; i--){
            if(zero[i]!=one[i]){
                brk = i+1;
                break;
            }
        }

        if(zero[n-1]!=one[n-1]){
            System.out.println("1");
            System.out.println(inp);
        }else{
            System.out.println("2");
            System.out.println(inp.substring(0,brk)+" "+inp.substring(brk,n));
        }

    }
}

import java.util.Scanner;

public class JavaApplication120 {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int x = sc.nextInt();
        String s = sc.next();
        int bal = 0;
        for(int i=0; i<s.length(); i++){
            if(s.charAt(i) == '0'){
                bal +=1;
            }else{
                bal -=1;
            }

        }
                    if(bal != 0){
                System.out.println("1"+"\n"+s);
            }else{
                System.out.println("2"+"\n"+s.substring(0, s.length()/2)+" "+s.substring(s.length()/2, s.length()));
            }
    }

}

import java.util.*;
public class codeforces3_1 {
	public static void main(String[] args) {
		int n, numOfZeros = 0, numOfOnes = 0;
		String s;
		Scanner sc = new Scanner(System.in);
		n = sc.nextInt();
		s = sc.next();
		for (int i = 0; i < n; i++) {
			if (s.charAt(i) == '0') {
				numOfZeros++;
			} else {
				numOfOnes++;
			}
		}
		int stringOneNumOfZeros = 0, stringOneNumOfOnes = 0, stringTwoNumOfZeros = numOfZeros,
				stringTwoNumOfOnes = numOfOnes;
		int x = 0;
		if (n == 1) {
			System.out.println("1");
			System.out.println(s);
		} else {
			for (int i = 0; i < s.length(); i++) {
				if (stringOneNumOfZeros != stringOneNumOfOnes && stringTwoNumOfZeros != stringTwoNumOfOnes) {
					x = i;
					break;
				}
				if (s.charAt(i) == '0') {
					stringOneNumOfZeros++;
					stringTwoNumOfZeros--;
				} else {
					stringOneNumOfZeros++;
					stringTwoNumOfOnes--;
				}
			}
			System.out.println("2");
			System.out.print(s.substring(0, x));
			System.out.print(" ");
			System.out.print(s.substring(x, n));
		}
	}
}

import java.io.*;
import java.util.*;
public class KeanuReeves
{
public static void main(String[] f)
{
	int N,i,bit0=0,bit1=0;
	String S;
	char ch[];
	Scanner sc=new Scanner(System.in);
	N=sc.nextInt();
	S=sc.next();
	ch=S.toCharArray();
	for(i=0;i<N;i++)
	{
		if(ch[i]=='1')
		{
			bit1++;
		}
		if(ch[i]=='0')
			bit0++;
	}
	if(N%2!=0)
	{
		System.out.println("1");
		System.out.print(S);
	}
	else if((N/2)%2!=0)
	{
		System.out.println("2");
		System.out.print(new String(S.substring(0,N/2))+" ");
		System.out.print(new String(S.substring(N/2,N))+" ");
	}
	else
	{
		System.out.println("2");
		System.out.print(new String(S.substring(0,(N/2+1)))+" ");
		System.out.print(new String(S.substring((N/2+1),N))+" ");
	}
}
}

import java.io.*;
import java.util.*;
import java.math.*;
import java.lang.*;
import static java.lang.Math.*;

public class Main implements Runnable
{
	static class InputReader
	{
		private InputStream stream;
		private byte[] buf = new byte[1024];
		private int curChar;
		private int numChars;
		private SpaceCharFilter filter;
		private BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

		public InputReader(InputStream stream)
		{
			this.stream = stream;
		}

		public int read()
		{
			if (numChars==-1)
				throw new InputMismatchException();

			if (curChar >= numChars)
			{
				curChar = 0;
				try
				{
					numChars = stream.read(buf);
				}
				catch (IOException e)
				{
					throw new InputMismatchException();
				}

				if(numChars <= 0)
					return -1;
			}
			return buf[curChar++];
		}

		public String nextLine()
		{
			String str = "";
			try
			{
				str = br.readLine();
			}
			catch (IOException e)
			{
				e.printStackTrace();
			}
			return str;
		}
		public int nextInt()
		{
			int c = read();

			while(isSpaceChar(c))
				c = read();

			int sgn = 1;

			if (c == '-')
			{
				sgn = -1;
				c = read();
			}

			int res = 0;
			do
			{
				if(c<'0'||c>'9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			}
			while (!isSpaceChar(c));

			return res * sgn;
		}

		public long nextLong()
		{
			int c = read();
			while (isSpaceChar(c))
				c = read();
			int sgn = 1;
			if (c == '-')
			{
				sgn = -1;
				c = read();
			}
			long res = 0;

			do
			{
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			}
			while (!isSpaceChar(c));
				return res * sgn;
		}

		public double nextDouble()
		{
			int c = read();
			while (isSpaceChar(c))
				c = read();
			int sgn = 1;
			if (c == '-')
			{
				sgn = -1;
				c = read();
			}
			double res = 0;
			while (!isSpaceChar(c) && c != '.')
			{
				if (c == 'e' || c == 'E')
					return res * Math.pow(10, nextInt());
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			}
			if (c == '.')
			{
				c = read();
				double m = 1;
				while (!isSpaceChar(c))
				{
					if (c == 'e' || c == 'E')
						return res * Math.pow(10, nextInt());
					if (c < '0' || c > '9')
						throw new InputMismatchException();
					m /= 10;
					res += (c - '0') * m;
					c = read();
				}
			}
			return res * sgn;
		}

		public String readString()
		{
			int c = read();
			while (isSpaceChar(c))
				c = read();
			StringBuilder res = new StringBuilder();
			do
			{
				res.appendCodePoint(c);
				c = read();
			}
			while (!isSpaceChar(c));

			return res.toString();
		}

		public boolean isSpaceChar(int c)
		{
			if (filter != null)
				return filter.isSpaceChar(c);
			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
		}

		public String next()
		{
			return readString();
		}

		public interface SpaceCharFilter
		{
			public boolean isSpaceChar(int ch);
		}
	}
	public static void main(String args[]) throws Exception
	{
		new Thread(null, new Main(),"Main",1<<27).start();
	}

	public void run(){
        InputReader sc=new InputReader(System.in);
        PrintWriter out=new PrintWriter(System.out);
        int n=sc.nextInt();
        String s=sc.next();
            char a[]=s.toCharArray();
            int one=0;
            int zero=0;
            for(int i=0;i<n;i++)
            {
                if(a[i]==1)
                {
                    one++;
                }
                else
                {
                    zero++;
                }
            }
            if(one==zero)
            {
                out.println("1");
                out.println(s.substring(0,n));
            }
            else{
            if(n==1)
            {
                out.println("1");
                out.println(s.substring(0,1));
            }
            else
            {
                out.println("2");
            out.println(s.substring(0,n-1)+" "+s.substring(n-1,n));
            }
            }
        out.flush();
		out.close();
	}
}

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        String s = scan.next();
        if(n==1){
            System.out.println(s);
        }

        else{
            for(int i=0;i<n/2;i++){
                System.out.print(s.charAt(i));
            }
            System.out.print(" ");
            for(int i=n/2;i<n;i++){
                System.out.print(s.charAt(i));
            }
        }
    }
}

import java.util.HashSet;
import java.util.Scanner;

public class Main1189A {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while (in.hasNext()) {
            int n = in.nextInt();
            String s = in.next();

            if (n % 2 == 1 || isSame(s) || isOdd(s)) {
                System.out.println(1);
                System.out.println(s);
            } else {
                System.out.println(2);
                System.out.println(s.charAt(0) + " " + s.substring(1));
            }
        }
    }

    public static boolean isSame(String s) {
        HashSet<Character> set = new HashSet<>();
        char[] ch = s.toCharArray();
        for (char c : ch) {
            set.add(c);
        }
        return set.size() == 1;
    }

    public static boolean isOdd(String s) {
        char[] ch = s.toCharArray();
        int one = 0;
        int zero = 0;
        for (char c : ch) {
            if (c == '0') {
                zero++;
            } else {
                one++;
            }
        }
        return (zero % 2 == 1) && (one % 2 == 1) && (zero != one);
    }

}

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

public class cheap {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n=sc.nextInt();
       String s=sc.next();
       int count0=0;
       int count1=0;
       int start=0;
       int end=n-1;
        for(int i=0;i<s.length();i++)
        {
            if(s.charAt(i)=='1')
            {
                count1++;
            }else{
                count0++;
            }
        }
        if(count1!=count0)
        {
           System.out.println("1");
           System.out.println(s);
        }else{
            start=0;
            end=n-1;
            int mid=start+(end-start)/2;
            System.out.println("2");
            System.out.println(s.substring(0,mid+1)+"");
            System.out.println(s.substring(mid+1,n)+"");
          //  System.out.println(s.charAt(n-1));
        }
    }
}

import java.util.ArrayList;
import java.util.Scanner;

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
/**
 *
 * @author anhnth37
 */
public class A_1189 {

    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int n = input.nextInt();
        String s = input.next();

        if (checkEqual(n, s)) {
            int t = n / 2;
            String s1 = "";
            String s2 = "";
            do {
                s1 = s.substring(0, t);
                s2 = s.substring(t);
                t++;
            } while (checkEqual(s1.length(), s1) && checkEqual(s2.length(), s2));

            System.out.println(s1 + " " + s2);
        } else {
            System.out.println("1");
            System.out.println(s);
        }
    }

    public static boolean checkEqual(int n, String s) {
        int countZero = 0;
        int countOne = 0;
        for (int i = 0; i < n; i++) {
            if (s.charAt(i) == '0') {
                countZero++;
            } else {
                countOne++;
            }
        }
        return countZero == countOne;
    }
}

import java.util.*;

public class geek {

    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        int n=s.nextInt();
        String st=s.next();
        int zeroes=0;
        int ones=0;
        for(int i=0;i<n;i++){
            if(st.charAt(i)=='0'){
                zeroes++;
            }else{
                ones++;
            }
        }
        if(zeroes!=ones){
            System.out.println("1\n"+st);
        }else {
            if (n == 2) {
                System.out.println("2\n" + st.charAt(0) + " " + st.charAt(1));
            } else {
                System.out.println("2\n" + st.substring(1, n - 1) + " " + st.charAt(n - 1));
            }
        }
       }
            }

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
 public class Acm {
public static void main (String args[]){
Scanner sc = new Scanner ();
sc.nextInt();
String s =sc.nextToken();
String r ="";
int p = 1;
boolean f = false ;
while (!isgood(s)||!f){
	if (!f)p--;
	p++;f=true;
r+=s.charAt(0)+" ";
String k = s;
	s= "";
	for (int i = 1; i<k.length();i++)
		s+=(k.charAt(i)+"");

}
System.out.println(p);
System.out.println(r+s);

}
public static boolean isgood (String s ){
	int z =0;
	int o=0;
	for (int i = 0;i<s.length();i++)
		if (s.charAt(i)=='0')z++;
		else o++;
	if (z==o&&z!=0&&o!=0)return false ;
	else return true ;
}
}

/*
for (int h = 0 ;h<n ;h++){

}
*/

 class Scanner {
		BufferedReader br;
		StringTokenizer st;

		public Scanner(String s) {
			try {
				br = new BufferedReader(new FileReader(s));
			} catch (FileNotFoundException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}

		public Scanner() {
			br = new BufferedReader(new InputStreamReader(System.in));
		}

		String nextToken() {
			while (st == null || !st.hasMoreElements()) {
				try {
					st = new StringTokenizer(br.readLine());
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			return st.nextToken();
		}

		int nextInt() {
			return Integer.parseInt(nextToken());
		}

		long nextLong() {
			return Long.parseLong(nextToken());
		}

		double nextDouble() {
			return Double.parseDouble(nextToken());
		}
	}

import java.util.*;
import java.io.*;
public class Div2_572_Virtual {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) {
        FastReader fs = new FastReader();

        String inp = fs.next();
        int n = inp.length();
        int co1 = 0 ; int co2 = 0 ;
        int zero[] = new int[n];
        int one[] = new int[n];
        for(int i=0 ; i<n ; i++){
            if(inp.charAt(i)=='0'){
                co1++;
            }else{
                co2++;
            }
            zero[i]=co1;
            one[i]=co2;
        }
        if(zero[n-1]!=one[n-1]){
            System.out.println("1");
            System.out.println(inp);
        }
        else{
            System.out.println("2");
            System.out.println(inp.substring(0,1)+" "+inp.substring(1,n));
        }

    }
}

import java.util.*;
import java.lang.*;
import java.io.*;
import java.math.*;
//BigInteger A;
//A= BigInteger.valueOf(54);
//ArrayList<Integer> a=new ArrayList<>();
//TreeSet<Integer> ts=new TreeSet<>();
//HashMap<Integer,Integer> hm=new HashMap<>();
public final class Minimal
{
    public static boolean good(String s)
    {
        int c0=0,c1=0;
        for(int i=0;i<s.length();i++)
        {
            if(s.charAt(i)=='0')
            ++c0;
            else
            ++c1;
        }
        if(c0==c1)
        return false;
        return true;
    }
    public static void main(String[]args)
    {
        FastReader ob=new FastReader();
        int n=ob.nextInt();
        String s=ob.next();
        if(n%2==0)
        {
            int c0=0,c1=0;
            for(int i=0;i<s.length();i++)
            {
                if(s.charAt(i)=='0')
                ++c0;
                else
                ++c1;
            }
            if(n==c0||n==c1)
            {
                System.out.println("1");
                System.out.println(s);
                return;
            }
            for(int i=1;i<s.length();i++)
            {
                String s1=s.substring(0,i);
                String s2=s.substring(i);
                if(good(s1)&&good(s2))
                {
                    System.out.println("2");
                    System.out.println(s1+" "+s2);
                    break;
                }
            }
        }
        else
        {
            System.out.println("1");
            System.out.println(s);
        }
    }
}
class FastReader {
    BufferedReader br;
    StringTokenizer st;
    public FastReader() {
        br = new BufferedReader(new InputStreamReader(System.in));
    }

    public String next() {
        while (st == null || !st.hasMoreElements()) {
            try {
                st = new StringTokenizer(br.readLine());
            } catch (IOException e)  {
                e.printStackTrace();
            }
        }
        return st.nextToken();
    }
    public String nextLine()
    {
        String s="";
        try {
        s=br.readLine();
        } catch (IOException e)  {
                e.printStackTrace();
            }
        return s;
    }
    public int nextInt() {
        return Integer.parseInt(next());
    }
    public long nextLong() {
        return Long.parseLong(next());
    }
    public double nextDouble() {
        return Double.parseDouble(next());
    }
}

import java.util.*;
public class div572{
	public static void main(String s[]){
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		String st = sc.next();
		int one=0;
		int zero=0;
		for(int i=0;i<st.length();i++){
			if(st.charAt(i)=='0')
				zero++;
			else one++;
		}
		if(zero!=one){
			System.out.println("1");
			for(int i=0;i<n;i++){
				System.out.print(st.charAt(i)+" ");
			}
			System.out.println();
			return;
		}else{
			int index=-1;
			System.out.print(st.substring(0,n-1)+" "+st.substring(n-1));
			System.out.println();
		}
	}
}

    import java.util.Scanner;
    public class Code {
            public static void main(String[] args) {
                Scanner input = new Scanner(System.in);
                int n = input.nextInt(),
                    z = 0, a = 0;
                String s = input.next();
                for (int i = 0; i < s.length(); i++) {
                    if (s.charAt(i) == '0') z++;
                    else a++;
                }
                if (z == 0 || a == 0) {
                    System.out.println(1);
                    System.out.println(s);
                } else {
                    System.out.println(2);
                    for (int i = 0; i < a; i++)
                            System.out.print(1);

                    System.out.print(" ");

                      for (int i = 0; i < z; i++)
                            System.out.print(0);

                    System.out.println();
                }
            }
    }

import java.util.Scanner;

public class JavaApplication155 {

    public static void main(String[] args){
       Scanner sc = new Scanner(System.in);

       int n = sc.nextInt();
       String s =sc.next();
       int count = 0;
       int count2 = 0;
       for(int i=0; i<s.length(); i++){
           if(s.charAt(i) == '0')
               count++;
           else{
               count--;
               count2++;
           }

       }
       if(count != 0)
           System.out.println("1"+"\n"+s);
       else
           System.out.println("2"+"\n"+s.substring(0, count2)+" "+s.substring(count2));

    }

}

import java.util.*;
public class Solution {

    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        String s = scan.next();
        //System.out.println(s);
        s = sortString(s);
        int count1 = 0,count0 = 0;
        for(int i=0;i<s.length();i++) {
            if(s.charAt(i)=='1')
                count1++;
            else if(s.charAt(i)=='0')
                count0++;
        }

        if(count1!=count0) {
            System.out.println(1);
            System.out.println(s);
        }
        else {
            System.out.println(2);
            String s1 = "",s2 = "";
            for(int i=0;i<s.length();i++) {
                if(s.charAt(i)=='0') {
                    s1+=s.charAt(i);
                }
                if(s.charAt(i)=='1') {
                    s2+=s.charAt(i);
                }
            }
            System.out.print(s1+" "+s2);
        }
    }
    public static String sortString(String inputString)
    {
        // convert input string to char array
        char tempArray[] = inputString.toCharArray();

        // sort tempArray
        Arrays.sort(tempArray);

        // return new sorted string
        return new String(tempArray);
    }
}

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

import static java.lang.Math.*;

public class Main implements Runnable {
    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private SpaceCharFilter filter;
        private BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public int read() {
            if (numChars==-1)
                throw new InputMismatchException();

            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                }
                catch (IOException e) {
                    throw new InputMismatchException();
                }

                if(numChars <= 0)
                    return -1;
            }
            return buf[curChar++];
        }

        public String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            }
            catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
        public int nextInt() {
            int c = read();

            while(isSpaceChar(c))
                c = read();

            int sgn = 1;

            if (c == '-') {
                sgn = -1;
                c = read();
            }

            int res = 0;
            do {
                if(c<'0'||c>'9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            }
            while (!isSpaceChar(c));

            return res * sgn;
        }

        public long nextLong() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            long res = 0;

            do {
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            }
            while (!isSpaceChar(c));
                return res * sgn;
        }

        public double nextDouble() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            double res = 0;
            while (!isSpaceChar(c) && c != '.') {
                if (c == 'e' || c == 'E')
                    return res * Math.pow(10, nextInt());
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            }
            if (c == '.') {
                c = read();
                double m = 1;
                while (!isSpaceChar(c)) {
                    if (c == 'e' || c == 'E')
                        return res * Math.pow(10, nextInt());
                    if (c < '0' || c > '9')
                        throw new InputMismatchException();
                    m /= 10;
                    res += (c - '0') * m;
                    c = read();
                }
            }
            return res * sgn;
        }

        public String readString() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            StringBuilder res = new StringBuilder();
            do {
                res.appendCodePoint(c);
                c = read();
            }
            while (!isSpaceChar(c));

            return res.toString();
        }

        public boolean isSpaceChar(int c) {
            if (filter != null)
                return filter.isSpaceChar(c);
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public String next() {
            return readString();
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);
        }
    }
    public static void main(String args[]) throws Exception {
        new Thread(null, new Main(),"Main",1<<26).start();
    }
    public void run() {
        InputReader sc = new InputReader(System.in);
        PrintWriter w = new PrintWriter(System.out);

                  int n=sc.nextInt();
                  String s=sc.next();
                  int i=0,f1=0,s1=0;

                  for(i=0;i<s.length();i++)
                  {
                                  if(i<s.length()/2 && s.charAt(i)=='1')
                                  {
                                                    f1++;
                                  }
                                  if(i>=s.length()/2 && s.charAt(i)=='1')
                                  {
                                                    s1++;
                                  }
                  }

                  if(n%2==1)
                  {
                                    w.println(1);
                                    w.print(s);
                  }
                  else
                  {
                                    if((n/2)%2==1 && (n-n/2)%2==1)
                                    {
                                                      w.println(2);
                                                      for(i=0;i<n/2;i++)
                                                      {
                                                                        w.print(s.charAt(i));
                                                      }
                                                      w.print(" ");
                                                      for(i=n/2;i<n;i++)
                                                      {
                                                                        w.print(s.charAt(i));
                                                      }
                                    }
                                    else if((n/2)%2==0 && (n-n/2)%2==0)
                                    {
                                                      w.println(2);
                                                      for(i=0;i<=n/2;i++)
                                                      {
                                                                        w.print(s.charAt(i));
                                                      }
                                                      w.print(" ");
                                                      for(i=n/2+1;i<n;i++)
                                                      {
                                                                        w.print(s.charAt(i));
                                                      }
                                    }
                                    else
                                    {

                                                      if((n/2)%2==1)
                                                      {
                                                                   w.println(3);
                                                                        for(i=0;i<n/2;i++)
                                                                        {
                                                                                w.print(s.charAt(i));
                                                                        }
                                                                        w.print(" "+s.charAt(i)+" ");
                                                                        for(i=n/2+1;i<n;i++)
                                                                        {
                                                                                w.print(s.charAt(i));
                                                                        }
                                                      }
                                                      else
                                                      {
                                                                        w.println(3);
                                                                        for(i=0;i<n/2-1;i++)
                                                                        {
                                                                                w.print(s.charAt(i));
                                                                        }
                                                                        w.print(" "+s.charAt(i)+" ");
                                                                        for(i=n/2;i<n;i++)
                                                                        {
                                                                                w.print(s.charAt(i));
                                                                        }
                                                      }

                                    }
                  }

        w.close();
    }

}

import java.util.Scanner;

public class KeanuReeeves2 {

	public static void main(String[] args) {

		Scanner sc = new Scanner(System.in);

		int n = sc.nextInt();

		String str = sc.next();
		int len = str.length();
		int zero = 0;
		int one = 0;
		int temp1=0 ,temp0=0;

		if(len==1) {
			System.out.println(1);
			System.out.println(str);
		}

		for(int i = 0; i<len; i++) {

			if(str.charAt(i)=='0') {
				zero += 1;
				temp0 = i;
			}
			if(str.charAt(i)=='1') {
				one += 1;
				temp1  = i;
			}
		}

//		System.out.println("Zeros "+zero);
//		System.out.println("Ones "+one);
		if(len>1) {
			if(one > zero) {
				System.out.println(2);
				System.out.println(str.substring(0, temp0) +str.subSequence(temp0+1, len)+" "+str.charAt(temp0));
			}

			else if(zero >one) {
				System.out.println(2);
				System.out.println(str.substring(0, temp1)+str.substring(temp1+1, len)+" "+str.charAt(temp1));
			}

			else if(one == zero) {

			 System.out.println(2);
			 System.out.print(str.substring(0, len-1)+" "+str.charAt(len-1));

			}

			else if(zero == 0) {
				System.out.println(1);
				System.out.println(str);
			}

			else if(one== 0) {
				System.out.println(1);
				System.out.println(str);
			}
		}

	}

	}

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

import static java.lang.Math.*;

public class Main implements Runnable {
    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private SpaceCharFilter filter;
        private BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public int read() {
            if (numChars==-1)
                throw new InputMismatchException();

            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                }
                catch (IOException e) {
                    throw new InputMismatchException();
                }

                if(numChars <= 0)
                    return -1;
            }
            return buf[curChar++];
        }

        public String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            }
            catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
        public int nextInt() {
            int c = read();

            while(isSpaceChar(c))
                c = read();

            int sgn = 1;

            if (c == '-') {
                sgn = -1;
                c = read();
            }

            int res = 0;
            do {
                if(c<'0'||c>'9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            }
            while (!isSpaceChar(c));

            return res * sgn;
        }

        public long nextLong() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            long res = 0;

            do {
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            }
            while (!isSpaceChar(c));
                return res * sgn;
        }

        public double nextDouble() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            double res = 0;
            while (!isSpaceChar(c) && c != '.') {
                if (c == 'e' || c == 'E')
                    return res * Math.pow(10, nextInt());
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            }
            if (c == '.') {
                c = read();
                double m = 1;
                while (!isSpaceChar(c)) {
                    if (c == 'e' || c == 'E')
                        return res * Math.pow(10, nextInt());
                    if (c < '0' || c > '9')
                        throw new InputMismatchException();
                    m /= 10;
                    res += (c - '0') * m;
                    c = read();
                }
            }
            return res * sgn;
        }

        public String readString() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            StringBuilder res = new StringBuilder();
            do {
                res.appendCodePoint(c);
                c = read();
            }
            while (!isSpaceChar(c));

            return res.toString();
        }

        public boolean isSpaceChar(int c) {
            if (filter != null)
                return filter.isSpaceChar(c);
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public String next() {
            return readString();
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);
        }
    }
    public static void main(String args[]) throws Exception {
        new Thread(null, new Main(),"Main",1<<26).start();
    }
    public void run() {
        InputReader sc = new InputReader(System.in);
        PrintWriter w = new PrintWriter(System.out);

       int n=sc.nextInt();
       String s=sc.next();
       if(s.length()==1) {
           w.println("1");
           w.println(s);
       }
       else if(s.length()==2){
           w.println("2");
           w.println(s.charAt(0)+ " "+s.charAt(1));
       }
       else {
           int zr=0;
           int or=0;
           int zl=0;
           int ol=0;
           int flag=0;
           for(int i=0;i<=n-1;i++){
               if(s.charAt(i)=='1') or++;
               else zr++;
           }

           if(or!=zr){
               w.println(1);
               w.println(s);
           }
           else{
               for(int i=0;i<n;i++){
               if(s.charAt(i)=='1'){
                   zr--;
                   zl++;
               }
               else {
                   or--;
                   ol++;
               }

               if(zr!=or && zl!=ol){
                   w.println("2");
                   w.println(s.substring(0,i+1)+" "+s.substring(i+1,n));
                   break;
               }
           }
           }

       }

        w.close();
    }
}

        import java.util.*;

        public class arr {

            public static void main(String[] args) {
                Scanner scn = new Scanner(System.in);
int len=scn.nextInt();
String arr=scn.next();
int co0=0,co1=0;
for(char c:arr.toCharArray()){
    if(c=='0')co0++;
    else co1++;
}
if(co1!=co0){
    System.out.println(arr);
}else{
System.out.print(arr.charAt(0)+" ");
if(len>1){
    System.out.println(arr.substring(1));
}
}
            }

}

import java.io.*;
import java.util.*;
public class KeanuReeves
{
public static void main(String[] f)
{
	int N,i,bit0=0,bit1=0;
	String S;
	char ch[];
	Scanner sc=new Scanner(System.in);
	N=sc.nextInt();
	S=sc.next();
	ch=S.toCharArray();
	for(i=0;i<N;i++)
	{
		if(ch[i]=='1')
		{
			bit1++;
		}
		if(ch[i]=='0')
			bit0++;
	}
	if(N%2!=0)
		System.out.print(S);
	else if((N/2)%2!=0)
	{
		System.out.print(new String(S.substring(0,N/2))+" ");
		System.out.print(new String(S.substring(N/2,N))+" ");
	}
	else
	{
		System.out.print(new String(S.substring(0,(N/2+1)))+" ");
		System.out.print(new String(S.substring((N/2+1),N))+" ");
	}
}
}

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

public class Main {
    public static void main(String[] args) throws IOException {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        InputReader.OutputWriter out = new InputReader.OutputWriter(outputStream);

        int n = in.nextInt();
        String s = in.next();
        int zeroes = 0;
        int ones = 0;
        for (int i = 0; i < s.length(); i++) {
            if(s.charAt(i) == '0') zeroes++;
            else ones++;
        }
        if(n == 1) {
            out.println(1);
            out.println(s);
        }else {
            char first = s.charAt(0);
            int mid = s.length()/2;
            if(first == '1') {
                if(zeroes!=ones-1) {
                    out.println(2);
                    out.println(first + " " + s.substring(1));
                }
                else {
                    out.println(2);
                    out.println(s.substring(0,mid) + " " +  s.substring(mid));
                }
            }
            else {
                if(ones!=zeroes-1) {
                    out.println(2);
                    out.println(first + " " + s.substring(1));
                }
                else {
                    out.println(2);
                    out.println(s.substring(0,mid) + " " +  s.substring(mid));
                }
            }

        }

        out.flush();
    }
}

class InputReader extends BufferedReader {
    StringTokenizer tokenizer;

    public InputReader(InputStream inputStream) {
        super(new InputStreamReader(inputStream), 32768);
    }

    public InputReader(String filename) {
        super(new InputStreamReader(Thread.currentThread().getContextClassLoader().getResourceAsStream(filename)));
    }

    public String next() {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
            try {
                tokenizer = new StringTokenizer(readLine());
            } catch (IOException e) {
                throw new RuntimeException();
            }
        }
        return tokenizer.nextToken();
    }

    public Integer nextInt() {
        return Integer.valueOf(next());
    }
    public Long nextLong() {return  Long.valueOf(next());}

    static class OutputWriter extends PrintWriter {
        public OutputWriter(OutputStream outputStream) {
            super(outputStream);
        }

        public OutputWriter(Writer writer) {
            super(writer);
        }

        public OutputWriter(String filename) throws FileNotFoundException {
            super(filename);
        }

        public void close() {
            super.close();
        }
    }
}

import java.util.Scanner;
import java.util.HashMap;
import java.util.Scanner;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Queue;
public class Codepractis {

    public static void main(String[] args) {

        Scanner scan=new Scanner(System.in);

        String str = scan.next();

         String zero = "";
         String one = "";
         for (int i = 0; i <str.length(); i++) {
             if(str.charAt(i)=='1')
                 one+=str.charAt(i);
             else
                 zero+=str.charAt(i);

        }

        System.out.println("2");
        System.out.println(one+" "+zero);

    }

}

import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.Queue;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
import java.util.Random;
import java.io.PrintWriter;
/*
    Solution Created: 02:11:32 12/07/2019
    Custom Competitive programming helper.
*/
public class Main {
	public static void solve(Reader in, Writer out) {
		int n = in.nextInt();
		String s = in.next();
		int ones = 0;
		for(int i = 0; i<n; i++) if(s.charAt(i)=='1') ones++;
		if(n%2!=0||n/2!=ones) System.out.println("1\n"+s);
		System.out.println(2);
		System.out.println(s.charAt(0)+" "+s.substring(1, n));
	}
	public static void main(String[] args) {
		Reader in = new Reader();
		Writer out = new Writer();
		solve(in, out);
		out.exit();
	}

static class Graph {
	private ArrayList<Integer> con[];
	private boolean[] visited;

	public Graph(int n) {
		con = new ArrayList[n];
		for (int i = 0; i < n; ++i)
			con[i] = new ArrayList();
		visited = new boolean[n];
	}

	public void reset() {
		Arrays.fill(visited, false);
	}

	public void addEdge(int v, int w) {
		con[v].add(w);
	}

	public void dfs(int cur) {
		visited[cur] = true;
		for (Integer v : con[cur]) {
			if (!visited[v]) {
				dfs(v);
			}
		}
	}
}

static class Reader {
	static BufferedReader br;
	static StringTokenizer st;
	private int charIdx = 0;
	private String s;

	public Reader() {
		this.br = new BufferedReader(new InputStreamReader(System.in));
	}

	public int[] na(int n) {
		int[] a = new int[n];
		for (int i = 0; i < n; i++)
			a[i] = nextInt();
		return a;
	}

	public double[] nd(int n) {
		double[] a = new double[n];
		for (int i = 0; i < n; i++)
			a[i] = nextDouble();
		return a;
	}

	public char nextChar() {
		if (s == null || charIdx >= s.length()) {
			if (st == null || !st.hasMoreTokens())
				try {
					readLine();
				} catch (Exception e) {
				}
			s = st.nextToken();
			charIdx = 0;
		}
		return s.charAt(charIdx++);
	}

	public long[] nl(int n) {
		long[] a = new long[n];
		for (int i = 0; i < n; i++)
			a[i] = nextLong();
		return a;
	}

	public char[] nca() {
		return next().toCharArray();
	}

	public String[] nS(int n) {
		String[] a = new String[n];
		for (int i = 0; i < n; i++)
			a[i] = next();
		return a;
	}

	public int nextInt() {
		if (st == null || !st.hasMoreTokens())
			try {
				readLine();
			} catch (Exception e) {
			}
		return Integer.parseInt(st.nextToken());
	}

	public double nextDouble() {
		if (st == null || !st.hasMoreTokens())
			try {
				readLine();
			} catch (Exception e) {
			}
		return Double.parseDouble(st.nextToken());
	}

	public Long nextLong() {
		if (st == null || !st.hasMoreTokens())
			try {
				readLine();
			} catch (Exception e) {
			}
		return Long.parseLong(st.nextToken());
	}

	public String next() {
		if (st == null || !st.hasMoreTokens())
			try {
				readLine();
			} catch (Exception e) {
			}
		return st.nextToken();
	}

	public static void readLine() {
		try {
			st = new StringTokenizer(br.readLine());
		} catch (Exception e) {
		}
	}
}

static class Sort {
	static Random random = new Random();
	public static void sortArray(int[] s) {
        shuffle(s);
        Arrays.sort(s);
    }
	public static void sortArray(long[] s) {
        shuffle(s);
        Arrays.sort(s);
    }
	public static void sortArray(String[] s) {
        shuffle(s);
        Arrays.sort(s);
    }
	public static void sortArray(char[] s) {
        shuffle(s);
        Arrays.sort(s);
    }
    private static void shuffle(int[] s) {
        for (int i = 0; i < s.length; ++i) {
            int j = random.nextInt(i + 1);
            int t = s[i];
            s[i] = s[j];
            s[j] = t;
        }
    }
    private static void shuffle(long[] s) {
        for (int i = 0; i < s.length; ++i) {
            int j = random.nextInt(i + 1);
            long t = s[i];
            s[i] = s[j];
            s[j] = t;
        }
    }
    private static void shuffle(String[] s) {
        for (int i = 0; i < s.length; ++i) {
            int j = random.nextInt(i + 1);
            String t = s[i];
            s[i] = s[j];
            s[j] = t;
        }
    }
    private static void shuffle(char[] s) {
        for (int i = 0; i < s.length; ++i) {
            int j = random.nextInt(i + 1);
            char t = s[i];
            s[i] = s[j];
            s[j] = t;
        }
    }
}

static class Util{
	    static boolean isPrime(int n) {
	        if (n <= 1) return false;
	        if (n <= 3) return true;
	        if (n % 2 == 0 || n % 3 == 0) return false;
	        for (int i = 5; i * i <= n; i = i + 6)
	            if (n % i == 0 || n % (i + 2) == 0)
	            return false;
	        return true;
	    }
		public static int upperBound(long[] a, long v) {
			int ans = -1;
			int l = 0, r = a.length-1;
			while(l<=r) {
				int mid = (l+r)/2;
				if(v>=a[mid]) {
					ans = mid;
					l = mid+1;
				}else r = mid-1;
			}
			return ans;
		}
		public static int lowerBound(long[] a, int v) {
			int ans = -1;
			int l = 0, r = a.length-1;
			while(l<=r) {
				int mid = (l+r)/2;
				if(v<=a[mid]) {
					ans = mid;
					r = mid-1;
				}else l = mid+1;
			}
			return ans;
		}
	    public static boolean[] getSieve(int n) {
	        boolean[] isPrime = new boolean[n+1];
	        for (int i = 2; i <= n; i++) isPrime[i] = true;
	        for (int i = 2; i*i <= n; i++) if (isPrime[i])
	                for (int j = i; i*j <= n; j++) isPrime[i*j] = false;
	        return isPrime;
	    }
	    public static int gcd(int a, int b) {
	        if (a == 0)
	            return b;
	        return gcd(b%a, a);
	    }
		public static long modAdd(long a, long b, long mod) {
			return (a%mod+b%mod)%mod;
		}
		public static long modMul(long a, long b, long mod) {
			return ((a%mod)*(b%mod))%mod;
		}
		public static void dbg(Object... o) {
			System.out.println(Arrays.deepToString(o));
		}
	}

static class Writer {
	private PrintWriter pw;
	public Writer(){
		pw = new PrintWriter(System.out);
	}

	public void printArray(int[] a) {
		for(int i = 0; i<a.length; i++) print(a[i]+" ");
	}
	public void printlnArray(int[] a) {
		for(int i = 0; i<a.length; i++) print(a[i]+" ");
		pw.println();
	}
	public void printArray(long[] a) {
		for(int i = 0; i<a.length; i++) print(a[i]+" ");
	}
	public void printlnArray(long[] a) {
		for(int i = 0; i<a.length; i++) print(a[i]+" ");
		pw.println();
	}
	public void print(Object o) {
		pw.print(o.toString());
	}
	public void println(Object o) {
		pw.println(o.toString());
	}
	public void println() {
		pw.println();
	}
	public void flush() {
		pw.flush();
	}
	public void exit() {
		pw.close();
	}
}
}

import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;

public class cf_572_2_a {
    public static void main(String[] args) throws Exception {
        FastScanner f = new FastScanner();
        int T = f.nextInt();
//        while (T-- > 0) {
//            int n = f.nextInt();
//            int[] a = f.nextIntArray(n);
//
//        }
        String a = f.next();
        int zeros = 0;
        int ones = 0;
        for (int i = 0; i < T; i++) {
            if (a.charAt(i)=='0')
                zeros++;
            else ones++;
        }

        if (zeros==ones){
            System.out.println("2");
            System.out.print(a.substring(0,T-2) + " " + a.charAt(T-1));

        }
        else {
            System.out.println("1");
            System.out.println(a);
        }
    }
}

class FastScanner {
    public int BS = 1<<16;
    public char NC = (char)0;
    byte[] buf = new byte[BS];
    int bId = 0, size = 0;
    char c = NC;
    double num = 1;
    BufferedInputStream in;

    public FastScanner() {
        in = new BufferedInputStream(System.in, BS);
    }

    public FastScanner(String s) {
        try {
            in = new BufferedInputStream(new FileInputStream(new File(s)), BS);
        }
        catch (Exception e) {
            in = new BufferedInputStream(System.in, BS);
        }
    }

    public char nextChar(){
        while(bId==size) {
            try {
                size = in.read(buf);
            }catch(Exception e) {
                return NC;
            }
            if(size==-1)return NC;
            bId=0;
        }
        return (char)buf[bId++];
    }

    public int nextInt() {
        return (int)nextLong();
    }

    public long nextLong() {
        num=1;
        boolean neg = false;
        if(c==NC)c=nextChar();
        for(;(c<'0' || c>'9'); c = nextChar()) {
            if(c=='-')neg=true;
        }
        long res = 0;
        for(; c>='0' && c <='9'; c=nextChar()) {
            res = (res<<3)+(res<<1)+c-'0';
            num*=10;
        }
        return neg?-res:res;
    }

    public double nextDouble() {
        double cur = nextLong();
        return c!='.' ? cur:cur+nextLong()/num;
    }

    public String next() {
        StringBuilder res = new StringBuilder();
        while(c<=32)c=nextChar();
        while(c>32) {
            res.append(c);
            c=nextChar();
        }
        return res.toString();
    }

    public String nextLine() {
        StringBuilder res = new StringBuilder();
        while(c<=32)c=nextChar();
        while(c!='\n') {
            res.append(c);
            c=nextChar();
        }
        return res.toString();
    }

    public boolean hasNext() {
        if(c>32)return true;
        while(true) {
            c=nextChar();
            if(c==NC)return false;
            else if(c>32)return true;
        }
    }

    public int[] nextIntArray(int n) {
        int[] res = new int[n];
        for(int i = 0; i < n; i++) res[i] = nextInt();
        return res;
    }

    public char[] nextCharArray(int n) {
        char[] res = new char[n];
        for (int i = 0; i < n; i++) {
            res[i] = nextChar();
        }
        return res;
    }

}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class A
{
	public static void main(String args[])throws IOException
	{
		BufferedReader BR=new BufferedReader (new InputStreamReader(System.in));

		int n = Integer.parseInt(BR.readLine());
		String str=BR.readLine();

		int o=0,z=0;
		for(int i=0;i<n;i++)
		{
			char ch=str.charAt(i);
			if(ch=='1')
				o++;
			if(ch=='0')
				z++;
		}

		if(o==z)
		{
			System.out.println(str.substring(0,n-1)+" "+str.charAt(n-1));
		}
		else
		{
			System.out.println("1");
		}

	}
}

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

public class june5_3
{

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

		FastReader scan=new FastReader();
		 int n=scan.nextInt();
		 String s=scan.next();
		 int count1=0;
		 int count0=0;
		 int min=Integer.MAX_VALUE;
		 for(int i=0;i<n;i++){
			if(s.charAt(i)=='0') count0++;
			else count1++;
		 }
		 if(count1!=count0) System.out.println(1);
		 else{
			 String ans="";
			 ans+=s.charAt(0);
			 ans+=" ";
			 ans+=s.substring(1, n);
			 System.out.println(ans);
		 }
	}

		 static class FastReader{
	          BufferedReader in;
	          StringTokenizer st;
	          public FastReader(){
	              in=new BufferedReader(new InputStreamReader(System.in));
	          }
	          String next(){
	              while(st==null || !st.hasMoreElements()){
	                  try{
	                      st=new StringTokenizer(in.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 str19 = "";
	            try{
	                str19 = in.readLine();
	            }
	            catch (IOException e){
	                e.printStackTrace();
	             }
	            return str19;
	        }
	      }
	}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Scanner;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author ky112233
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        Scanner in = new Scanner(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        AKeanuReeves solver = new AKeanuReeves();
        solver.solve(1, in, out);
        out.close();
    }

    static class AKeanuReeves {
        public void solve(int testNumber, Scanner in, PrintWriter out) {
            int n = in.nextInt();
            String str = in.next();
            if (str.length() == 1) {
                out.println(1);
                out.println(str);
                return;
            }
            int zeroCnt = 0, oneCnt = 0;
            for (int i = 0; i < str.length(); i++) {
                if (str.charAt(0) == '1') oneCnt++;
                else zeroCnt++;
            }
            if (zeroCnt == oneCnt) {
                out.println(1);
                out.println(str);
                return;
            }
            out.println(2);
            out.println(str.substring(0, 1) + " " + str.substring(1));
        }

    }
}

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

public class A {
	public static void main(String[] args) {
		MyScanner in = new MyScanner();
		int n=in.nextInt();
		String s=in.next();
		int z=0, o=0;
		for(int i=0; i<s.length(); i++) {
			if(s.charAt(i)=='0') z++;
			if(s.charAt(i)=='1') o++;
		}
		if(z!=o) {
			System.out.println(s);
			return;
		}
		System.out.println(s.substring(0,n-1)+" "+s.substring(n-1));
	}

	static class MyScanner {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st;
		String next() {
			while(st==null||!st.hasMoreTokens()) {
				try {
					st = new StringTokenizer(br.readLine());
				} catch (Exception e) {}
			}
			return st.nextToken();
		}
		int nextInt() {
			return Integer.parseInt(next());
		}
	}
}

//package round572;

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

public final class keanu
{
	public static void main(String[] args) throws IOException
	{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st = new StringTokenizer(br.readLine());
		int n = Integer.parseInt(st.nextToken());
		st = new StringTokenizer(br.readLine());
		String s = st.nextToken();
		int one = 0, zero = 0;
		for(int i=0;i<n;i++)
		{
			if(s.charAt(i) == '0')
			{
				zero++;
			}
			else
			{
				one++;
			}
		}
		if(one != zero)
		{
			System.out.println(1);
		}
		else
		{
			System.out.println(2);
		}
	}

}

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

public class Main {
	public static void solve(InputReader in) {
		int n = in.readInt();
		String s = in.readString();

		if(n == 1) {
			System.out.println(1); System.out.println(1);
			return;
		}

		System.out.println(2);
		System.out.print(s.substring(0,n/2) + " " + s.substring(n-n/2 , n));

	}
	public static void main(String[] args) {
		InputReader in = new InputReader(System.in);
		int t = 1;
		while(t-- > 0) {
			solve(in);
		}
	}
}

class InputReader{
	private InputStream stream;
	private byte[] buf = new byte[1024];
	private int curChar;
	private int numChars;
	private SpaceCharFilter filter;

	 public InputReader(InputStream stream) {
		this.stream = stream;
	}

     public int read() {
		if (numChars == -1)
			throw new InputMismatchException();
		if (curChar >= numChars) {
			curChar = 0;
			try {
				numChars = stream.read(buf);
			} catch (IOException e) {
				throw new InputMismatchException();
			}
			if (numChars <= 0)
				return -1;
		}
		return buf[curChar++];
	}

     public int readInt() {
		int c = read();
		while (isSpaceChar(c))
			c = read();
		int sgn = 1;
		if (c == '-') {
			sgn = -1;
			c = read();
		}
		int res = 0;
		do {
			if (c < '0' || c > '9')
				throw new InputMismatchException();
			res *= 10;
			res += c - '0';
			c = read();
		} while (!isSpaceChar(c));
		return res * sgn;
	}

     public String readString() {
		int c = read();
		while (isSpaceChar(c))
			c = read();
		StringBuilder res = new StringBuilder();
		do {
			res.appendCodePoint(c);
			c = read();
		} while (!isSpaceChar(c));
		return res.toString();
	}

     public long readLong() {
		int c = read();
		while (isSpaceChar(c)) {
			c = read();
		}
		int sgn = 1;
		if (c == '-') {
			sgn = -1;
			c = read();
		}
		long res = 0;
		do {
			if (c < '0' || c > '9') {
				throw new InputMismatchException();
			}
			res *= 10;
			res += c - '0';
			c = read();
		} while (!isSpaceChar(c));
		return res * sgn;
	}

     public boolean isSpaceChar(int c) {
		if (filter != null)
			return filter.isSpaceChar(c);
		return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
	}

     public String next() {
		return readString();
	}

     public interface SpaceCharFilter {
		public boolean isSpaceChar(int ch);
	}
}

import java.util.ArrayList;
import java.util.Scanner;

public class CF1189A {

	public static void main(String[] args) {
		Scanner s = new Scanner(System.in);
		int n = s.nextInt();
		s.nextLine();
		String line = s.nextLine();
		if(line.length()==1) {
			System.out.println(1);
			System.out.println(line);
		}else {
			System.out.println(2);
			for (int i = 1; i < line.length()-1; i++) {
				String a = line.substring(0, line.length()-i);
				String b  = line.substring(line.length()-i, line.length());
				if(isGood(a)&&isGood(b)) {
					System.out.println(a+" "+b);
					break;
				}
			}

		}

	}
	static boolean isGood(String s) {
		int countzero=0;
		int countone=0;
		for (int i = 0; i < s.length(); i++) {
			if(s.charAt(i)=='0') {
				countzero++;
			}else {
				countone++;
			}
		}
		if(countone!=countzero) {
			return true;
		}else {
			return false;
		}
	}
}

import java.util.Scanner;
public class A{
    static int count(char a,String list ){
        int res=0;
        for (int i=0;i<list.length();i++){
            if (list.charAt(i)==a){
                res=res+1;
            }
        }
        return res;
    }
    public static void main(String args[]){
        Scanner in=new Scanner(System.in);
        int n=in.nextInt();
        int res=0;
        String list= in.next();
        if (count('1',list)!=count('0',list)){
            System.out.println(1);
            res=1;
        }
        else if (n>1){
        System.out.println(2);}
        else{
            res=1;
            System.out.println(1);
        }
        if (res!=1){

        System.out.print(list.charAt(0));
        System.out.print(" ");
        for (int i=0;i<list.length()-1;i++){
            System.out.print(list.charAt(i));}}
        else{
            System.out.println(list);
        }
}
}

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

public class Main {

    static StringBuilder data;
    final static FastReader in = new FastReader();

    public static void main(String[] args) {
        int n = in.nextInt();
String s = in.nextLine();
        if(s.length()==1){
            System.out.println(1);
            System.out.println(s);
        }else{
            int z=0,o=0;
            for (int i = 0; i < s.length(); i++) {
                if(s.charAt(i)=='1'){
                    o++;
                }else{
                    z++;
                }
            }
            int f=0,t=0;
            for (int i = 0; i < s.length(); i++) {
                if(s.charAt(i)=='1'){

                   f++;
                     if(f!=t&&o-1!=z){
                         System.out.println(2);
                         System.out.println(s.substring(0,i+1)+" "+s.substring(i+1,s.length()));
                         break;
                     }
                }else{
                    t++;
                    if(t!=f&&o!=z-1){
                        System.out.println(2);
                        System.out.println(s.substring(0,i+1)+" "+s.substring(i+1,s.length()));
                        break;
                    }
                }
            }
        }

    }

    static void fileOut(String s) {
        File out = new File("output.txt");
        try {
            FileWriter fw = new FileWriter(out);
            fw.write(s);
            fw.flush();
            fw.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

    static class FastReader {
        BufferedReader br;
        StringTokenizer st;

        public FastReader() {
            br = new BufferedReader(new
                    InputStreamReader(System.in));
        }

        public FastReader(String path) {
            try {
                br = new BufferedReader(new
                        InputStreamReader(new FileInputStream(path)));
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
        }

        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());
        }

        float nextFloat() {
            return Float.parseFloat(next());
        }

        double nextDouble() {
            return Double.parseDouble(next());
        }

        String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
    }

}

// https://codeforces.com/contest/1189/problem/A

import java.util.Scanner;

public class Main {
  static int[] input = new int[200];
  static boolean hasPrintedBefore = false;
  static int printCnt = 0;
  static StringBuilder outBuilder = new StringBuilder();
  static boolean isOdd(int i) {
    if((i + 1) % 2 == 0) {
      return true;
    }
    return false;
  }

  static int cnt(int start, int end, int a) {
    int res = 0;
    for (int i = start; i < end; i++) {
      if (input[i] == a) {
        res += 1;
      }
    }
    return res;
  }

  static void print(int start, int end) {
    if (hasPrintedBefore) {
      outBuilder.append(" ");
    }
    for (int i = start; i < end; i++) {
      outBuilder.append(input[i]);
    }
    hasPrintedBefore = true;
    printCnt += 1;
    return;
  }

  static boolean isGood(int start, int end) {
    int numOfZero = cnt(start, end, 0);
    if (numOfZero == (end - start - numOfZero)) {
      return false;
    }
    return true;
  }

  // 包含start，不包含 end
  static void split(int start, int end) {
    int total = end - start;

    // 长度是奇数，可以直接输出
    if(isOdd(total)) {
      print(start, end);
      return;
    }

    // 只有长度是偶数，并且 0 和 1 个数相等时，才需要划分
    if(!isGood(start, end)) {
      if (end - start == 2) {
        split(start, (start+end)/2);
        split((start+end)/2, end);
      } else {
        split(start, (start+end)/2-1);
        split((start+end)/2-1, end);
      }
    } else {
      // 0、1不相等，也输出
      print(start, end);
    }
  }

  public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    int n = scanner.nextInt();

    CharSequence inputStr = scanner.next();
    for (int i = 0; i < n; i++) {
      input[i] = (inputStr.charAt(i) == '0') ? 0 : 1;
    }

    scanner.close();
    split(0, n);

    System.out.println(printCnt);
    System.out.println(outBuilder);
  }
}

import java.util.*;
public class div572{
	public static void main(String s[]){
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		String st = sc.next();
		int one=0;
		int zero=0;
		for(int i=0;i<st.length();i++){
			if(st.charAt(i)=='0')
				zero++;
			else one++;
		}
		if(zero!=one){
			System.out.println("1");
			for(int i=0;i<n;i++){
				System.out.print(st.charAt(i)+" ");
			}
			System.out.println();
			return;
		}else{
			System.out.println("2");
			System.out.print(st.substring(0,n-1)+" "+st.substring(n-1));
			System.out.println();
		}
	}
}

/*
by:-
                     _ __ ___ 119574
                    | '__/ __|
                    | |  \__ \
                    |_|  |___/

*/

import java.io.*;
import java.math.*;
import java.lang.*;
import java.text.*;
import java.util.*;
// import java.security.*;
// import java.util.regex.*;
// import java.util.Scanner;
// import java.io.IOException;
// import java.util.concurrent.*;
// import java.io.BufferedReader;
// import java.io.InputStreamReader;
// import java.util.StringTokenizer;

public class Template {
	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;
		}
	}

/*
Set<Integer> st = new HashSet<Integer>();st.add();
Map<String,Integer>hm=new HashMap< String,Integer>();
hm.put("a", new Integer(100));
Set< Map.Entry< String,Integer> > st = hm.entrySet();
for (Map.Entry< String,Integer> me:st) System.out.print(me.getKey()+":"+me.getValue());
long []a=new long[26];
Arrays.sort(a);
Collections.reverse(Arrays.asList(a));

*/

public static void main(String[] args) throws IOException {
	FastReader in=new FastReader();
	Long t=1L;
// 	t=in.nextLong();
	while(t-->0){
	    //code
	    int n=in.nextInt();
	    String s=in.nextLine();
	    long a=0,b=0;
	    for(int i=0;i<n;i++){
	        if(s.charAt(i)=='0')a++;
	        else b++;
	    }
	    if(a!=b)System.out.println("1\n"+s);
	    else {
	        System.out.println("2\n"+s.substring(0,1)+' '+s.substring(1,n-1));
	    }

    }
}}

import java.io.*;
import java.util.*;
public class codeforces{

    public static boolean isposs(String s,int c1,int c2){
        char[] a=new char[s.length()];
        if(c1==s.length()/2){
            for(int i=0;i<s.length();i+=2){
                if(s.charAt(i)!='1')
                return false;
            }
            for(int i=1;i<s.length();i+=2){
                if(s.charAt(i)!='0')
                return false;
            }
        }
        else{
            for(int i=0;i<s.length();i+=2){
                if(s.charAt(i)!='0')
                return false;
            }
            for(int i=1;i<s.length();i+=2){
                if(s.charAt(i)!='1')
                return false;
            }
        }
        return true;
    }

    public static void main(String[] args) throws IOException {
        InputStreamReader isr=new InputStreamReader(System.in);
        BufferedReader br=new BufferedReader(isr);
        PrintWriter out=new PrintWriter(System.out);
        StringBuilder str=new StringBuilder();
        // int t=Integer.parseInt(br.readLine());
        int[] arr;
        String[] lol;
        // while(t-->0){
            int n=Integer.parseInt(br.readLine());
            // arr=new int[n];
            String string=br.readLine();
            int c0=0,c1=0;
            for(int i=0;i<n;i++){
                if(string.charAt(i)=='0')
                c0++;
            }
            c1=n-c0;
            String a="",b="";
            if(c1==n || c1==0)
            System.out.println("1\n"+string);
            else if(n%2==1 && isposs(string, c0, c1))
                System.out.println("1\n"+string);

            else{
                System.out.println("2");
                int i=1;
                while(i<n){
                    a=string.substring(0,i);
                    b=string.substring(i);
                    int c10=0,c11=0;
                    for(int ii=0;ii<a.length();ii++){
                        if(a.charAt(ii)=='0')
                        c10++;
                        else
                        c11++;
                    }
                    // System.out.println(a+" "+c10+" "+c11+" "+b);
                    if(c10!=c11 && (c1-c11)!=(c0-c10)){
                        System.out.println(a+" "+b);
                        break;
                    }
                    i++;
                }
            }
        // }
        // System.out.print(str);
    }
}

// https://codeforces.com/contest/1189/problem/A

import java.util.Scanner;

public class Main {
  static int[] input = new int[200];
  static boolean hasPrintedBefore = false;
  static int printCnt = 0;
  static StringBuilder outBuilder = new StringBuilder();
  static boolean isOdd(int i) {
    if((i - 1) % 2 == 0) {
      return true;
    }
    return false;
  }

  static int cnt(int start, int end, int a) {
    int res = 0;
    for (int i = start; i < end; i++) {
      if (input[i] == a) {
        res += 1;
      }
    }
    return res;
  }

  static void print(int start, int end) {
    if (hasPrintedBefore) {
//      System.out.print(" ");
      outBuilder.append(" ");
    }
    for (int i = start; i < end; i++) {
//      System.out.print();
      outBuilder.append(input[i]);
    }
    hasPrintedBefore = true;
    printCnt += 1;
    return;
  }

  // 包含start，不包含 end
  static void split(int start, int end) {
    int total = end - start;

    // 长度是奇数，可以直接输出
    if(isOdd(total)) {
      print(start, end);
      return;
    }

    // 只有长度是偶数，并且 0 和 1 个数相等时，才需要划分
    int numOfZero = cnt(start, end, 0);
    if(numOfZero == total - numOfZero) {
      split(start, (start+end)/2);
      split((start+end)/2, end);
    } else {
      // 0、1不相等，也输出
      print(start, end);
    }
  }

  public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    int n = scanner.nextInt();

    CharSequence inputStr = scanner.next();
    for (int i = 0; i < n; i++) {
      input[i] = (inputStr.charAt(i) == '0') ? 0 : 1;
    }

    scanner.close();
    split(0, n);

    System.out.println(printCnt);
    System.out.println(outBuilder);
  }
}

import java.util.Scanner;

public class que1 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner scn=new Scanner(System.in);
		int n=scn.nextInt();
		String s=scn.next();
		mt(s);

	}

	public static void mt(String s) {
		if (s.length() == 1) {
			System.out.println(1);
			System.out.println(s);
			return;
		}
		int t0 = 0, t1 = 0;
		for (int i = 0; i < s.length(); i++) {
			int l = s.charAt(i) - '0';
			if (l == 0) {
				t0++;
			} else {
				t1++;
			}
		}
		if(t0==s.length()||t1==s.length()){
			System.out.println(1);
			System.out.println(s);
			return ;
		}
		int zy = 0, oy = 0;
		for (int i = 0; i < s.length(); i++) {
			int l = s.charAt(i) - '0';
			if (l == 0) {
				zy++;
			} else {
				oy++;
			}
			if (zy != oy && (t0 - zy != t1 - oy)) {
				String s1 = s.substring(0, i + 1);
				String s2 = s.substring(i + 1);
				System.out.println(2);
				System.out.println(s1 + " " + s2);
				break;
			}
		}
	}
}

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        String s = scan.next();

        if(n==1){
            System.out.println(n);
            System.out.print(s.charAt(0));
        }

        else{
            System.out.println(2);
            for(int i=0;i<n/2;i++){
                System.out.print(s.charAt(i));
            }
            System.out.print(" ");
            for(int i=n/2;i<n;i++){
                System.out.print(s.charAt(i));
            }
        }
    }
}

//package round572;

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

public final class keanu
{
	public static void main(String[] args) throws IOException
	{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st = new StringTokenizer(br.readLine());
		int n = Integer.parseInt(st.nextToken());
		st = new StringTokenizer(br.readLine());
		String s = st.nextToken();
		if(n%2==0)
		{
			System.out.println(1);
		}
		else
		{
			System.out.println(2);
		}
	}

}

import java.io.*;
import java.math.*;
import java.util.*;

public class test {

	static int INF = 1000000007;

	public static void main(String[] args) {
		// int test = fs.nextInt();
		int test = 1;
		for (int cases = 0; cases < test; cases++) {
			int n = fs.nextInt();
			char ar[] = fs.next().toCharArray();
			int count = 1;
			int o = 0;
			int z = 0;
			for (int i = 0; i < n; i++) {
				if (ar[i] == '0') {
					++z;
				} else {
					++o;
				}
			}
			if (n == 1) {
				System.out.println(String.valueOf(ar));
			} else {
				String s = String.valueOf(ar);
				if (z != o) {
					System.out.println(1);
					System.out.println(s);
				} else {
					System.out.println(2);
					System.out.println(s.substring(0, n - 1) + " " + ar[n - 1]);
				}
			}
			System.out.println(count);
		}
	}

	static long getDist(Pair a, Pair b) {
		long ans = (long) Math.abs(a.first - b.first) + (long) Math.abs(a.second - b.second);
		return ans;

	}

	static long power(long x, long y, long p) {
		long res = 1;
		x = x % p;
		while (y > 0) {
			if (y % 2 == 1)
				res = (res * x) % p;
			y = y >> 1;
			x = (x * x) % p;
		}
		return res;
	}

	static long modInverse(long n, long p) {
		return power(n, p - 2, p);
	}

	static long nCrModPFermat(long n, long r, long p) {
		long ans1 = 1;
		long i = n;
		long k = r;
		while (k > 0) {
			ans1 = mul(ans1, i, p);
			i--;
			k--;
		}
		long ans2 = 1;
		while (r > 0) {
			ans2 = mul(ans2, r, p);
			r--;
		}
		r = modInverse(ans2, p);
		ans1 = mul(ans1, r, p);
		return ans1;
	}

	static long facCalc(long total) {
		long ans = 1;
		for (long i = 2; i <= total; i++) {
			ans = mul(ans, i, INF);
		}
		return ans;
	}

	static long mul(long a, long b, long p) {
		return ((a % p) * (b % p)) % p;
	}

	static void sieve() {
		boolean prime[] = new boolean[101];
		Arrays.fill(prime, true);
		prime[1] = false;
		for (int i = 2; i * i <= prime.length - 1; i++) {
			for (int j = i * i; j <= prime.length - 1; j += i) {
				prime[j] = false;
			}
		}
	}

	public static int[] radixSort(int[] f) {
		return radixSort(f, f.length);
	}

	public static int[] radixSort(int[] f, int n) {
		int[] to = new int[n];
		{
			int[] b = new int[65537];
			for (int i = 0; i < n; i++)
				b[1 + (f[i] & 0xffff)]++;
			for (int i = 1; i <= 65536; i++)
				b[i] += b[i - 1];
			for (int i = 0; i < n; i++)
				to[b[f[i] & 0xffff]++] = f[i];
			int[] d = f;
			f = to;
			to = d;
		}
		{
			int[] b = new int[65537];
			for (int i = 0; i < n; i++)
				b[1 + (f[i] >>> 16)]++;
			for (int i = 1; i <= 65536; i++)
				b[i] += b[i - 1];
			for (int i = 0; i < n; i++)
				to[b[f[i] >>> 16]++] = f[i];
			int[] d = f;
			f = to;
			to = d;
		}
		return f;
	}

	static void printArray(int ar[]) {
		System.out.println(Arrays.toString(ar));
	}

	static class Pair {
		int first, second;

		public Pair(int first, int second) {
			this.first = first;
			this.second = second;
		}

	}

	static class Pair2 {
		int first;
		Pair second;

		public Pair2(int first, Pair second) {
			this.first = first;
			this.second = second;
		}

	}

	static class LongPair {
		long first, second;

		public LongPair(long first, long second) {
			this.first = first;
			this.second = second;
		}

	}

	static long expmodulo(long a, long b, long c) {
		long x = 1;
		long y = a;
		while (b > 0) {
			if (b % 2 == 1) {
				x = (x * y) % c;
			}
			y = (y * y) % c; // squaring the base
			b /= 2;
		}
		return (long) x % c;
	}

	// static int modInverse(int a, int m) {
	// int m0 = m;
	// int y = 0, x = 1;
	//
	// if (m == 1)
	// return 0;
	//
	// while (a > 1) {
	// int q = a / m;
	// int t = m;
	// m = a % m;
	// a = t;
	// t = y;
	// y = x - q * y;
	// x = t;
	// }
	// if (x < 0)
	// x += m0;
	// return x;
	// }

	static int gcd(int a, int b) {
		if (b == 0)
			return a;
		return gcd(b, a % b);
	}

	static void sortMyMapusingValues(HashMap<String, Integer> hm) {

		List<Map.Entry<String, Integer>> capitalList = new LinkedList<>(hm.entrySet());

		Collections.sort(capitalList, new Comparator<Map.Entry<String, Integer>>() {
			public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2) {
				return (o1.getValue()).compareTo(o2.getValue());
			}
		});
		HashMap<String, Integer> result = new HashMap<>();
		for (Map.Entry<String, Integer> entry : capitalList) {
			result.put(entry.getKey(), entry.getValue());
		}
	}

	static boolean ispowerof2(long num) {
		if ((num & (num - 1)) == 0)
			return true;
		return false;
	}

	static void primeFactors(int n) {
		while (n % 2 == 0) {
			System.out.print(2 + " ");
			n /= 2;
		}
		for (int i = 3; i <= Math.sqrt(n); i += 2) {
			while (n % i == 0) {
				System.out.print(i + " ");
				n /= i;
			}
		}
		if (n > 2)
			System.out.print(n);
	}

	static boolean isPrime(long n) {
		// Corner cases
		if (n <= 1)
			return false;
		if (n <= 3)
			return true;
		if (n % 2 == 0 || n % 3 == 0)
			return false;

		long sq = (long) Math.sqrt(n);
		for (int i = 5; i <= sq; i = i + 6)
			if (n % i == 0 || n % (i + 2) == 0)
				return false;

		return true;
	}

	static class Graph {
		HashMap<Integer, LinkedList<Integer>> hm = new HashMap<Integer, LinkedList<Integer>>();

		private void addVertex(int vertex) {
			hm.put(vertex, new LinkedList<>());
		}

		private void addEdge(int source, int dest, boolean bi) {
			if (!hm.containsKey(source))
				addVertex(source);
			if (!hm.containsKey(dest))
				addVertex(dest);
			hm.get(source).add(dest);
			if (bi) {
				hm.get(dest).add(source);
			}
		}

		private boolean uniCycle(int i, HashSet<Integer> visited, int parent) {
			visited.add(i);
			LinkedList<Integer> list = hm.get(i);
			Iterator<Integer> it = list.iterator();
			while (it.hasNext()) {
				Integer integer = (Integer) it.next();
				if (!visited.contains(integer)) {
					if (uniCycle(integer, visited, i))
						return true;
				} else if (integer != parent) {
					return true;
				}
			}
			return false;
		}

		private boolean uniCyclic() {
			HashSet<Integer> visited = new HashSet<Integer>();
			Set<Integer> set = hm.keySet();
			for (Integer integer : set) {
				if (!visited.contains(integer)) {
					if (uniCycle(integer, visited, -1)) {
						return true;
					}
				}
			}
			return false;
		}

		private boolean isbiCycle(int i, HashSet<Integer> visited, HashSet<Integer> countered) {
			if (countered.contains(i))
				return true;
			if (visited.contains(i))
				return false;
			visited.add(i);
			countered.add(i);
			LinkedList<Integer> list = hm.get(i);
			Iterator<Integer> it = list.iterator();
			while (it.hasNext()) {
				Integer integer = (Integer) it.next();
				if (isbiCycle(integer, visited, countered)) {
					return true;
				}
			}
			countered.remove(i);
			return false;
		}

		Boolean isReachable(int s, int d, int k) {
			if (hm.isEmpty()) {
				return false;
			}
			LinkedList<Integer> temp;
			boolean visited[] = new boolean[k];
			LinkedList<Integer> queue = new LinkedList<Integer>();
			visited[s] = true;
			queue.add(s);
			Iterator<Integer> i;
			while (queue.size() != 0) {
				s = queue.poll();
				int n;
				i = hm.get(s).listIterator();

				// Get all adjacent vertices of the dequeued vertex s
				// If a adjacent has not been visited, then mark it
				// visited and enqueue it
				while (i.hasNext()) {
					n = i.next();

					// If this adjacent node is the destination node,
					// then return true
					if (n == d)
						return true;

					// Else, continue to do BFS
					if (!visited[n]) {
						visited[n] = true;
						queue.add(n);
					}
				}
			}

			// If BFS is complete without visited d
			return false;
		}

		private boolean isbiCyclic() {
			HashSet<Integer> visited = new HashSet<Integer>();
			HashSet<Integer> countered = new HashSet<Integer>();
			Set<Integer> set = hm.keySet();
			for (Integer integer : set) {
				if (isbiCycle(integer, visited, countered)) {
					return true;
				}
			}
			return false;
		}
	}

	static class Node {
		Node left, right;
		int data;

		public Node(int data) {
			this.data = data;
		}

		public void insert(int val) {
			if (val <= data) {
				if (left == null) {
					left = new Node(val);
				} else {
					left.insert(val);
				}
			} else {
				if (right == null) {
					right = new Node(val);
				} else {
					right.insert(val);
				}
			}
		}

		public boolean contains(int val) {
			if (data == val) {
				return true;
			} else if (val < data) {
				if (left == null) {
					return false;
				} else {
					return left.contains(val);
				}
			} else {
				if (right == null) {
					return false;
				} else {
					return right.contains(val);
				}
			}
		}

		public void inorder() {
			if (left != null) {
				left.inorder();
			}
			System.out.print(data + " ");
			if (right != null) {
				right.inorder();
			}
		}

		public int maxDepth() {
			if (left == null)
				return 0;
			if (right == null)
				return 0;
			else {
				int ll = left.maxDepth();
				int rr = right.maxDepth();
				if (ll > rr)
					return (ll + 1);
				else
					return (rr + 1);
			}
		}

		public int countNodes() {
			if (left == null)
				return 1;
			if (right == null)
				return 1;
			else {
				return left.countNodes() + right.countNodes() + 1;
			}
		}

		public void preorder() {
			System.out.print(data + " ");
			if (left != null) {
				left.inorder();
			}

			if (right != null) {
				right.inorder();
			}

		}

		public void postorder() {
			if (left != null) {
				left.inorder();
			}

			if (right != null) {
				right.inorder();
			}
			System.out.print(data + " ");

		}

		public void levelorder(Node node) {
			LinkedList<Node> ll = new LinkedList<Node>();
			ll.add(node);
			getorder(ll);

		}

		public void getorder(LinkedList<Node> ll) {
			while (!ll.isEmpty()) {
				Node node = ll.poll();
				System.out.print(node.data + " ");
				if (node.left != null)
					ll.add(node.left);
				if (node.right != null)
					ll.add(node.right);
			}
		}
	}

	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;
		}
	}

	static class OutputWriter {
		private final PrintWriter writer;

		public OutputWriter(OutputStream outputStream) {
			writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
		}

		public OutputWriter(Writer writer) {
			this.writer = new PrintWriter(writer);
		}

		public void print(Object... objects) {
			for (int i = 0; i < objects.length; i++) {
				if (i != 0)
					writer.print(' ');
				writer.print(objects[i]);
			}
		}

		public void printLine(Object... objects) {
			print(objects);
			writer.println();
		}

		public void close() {
			writer.close();
		}

		public void flush() {
			writer.flush();
		}

	}

	private static final FastReader fs = new FastReader();
	private static final OutputWriter op = new OutputWriter(System.out);
}

import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;

public class cf_572_2_a {
    public static void main(String[] args) throws Exception {
        FastScanner f = new FastScanner();
        int T = f.nextInt();
//        while (T-- > 0) {
//            int n = f.nextInt();
//            int[] a = f.nextIntArray(n);
//
//        }
        String a = f.next();
        int zeros = 0;
        int ones = 0;
        for (int i = 0; i < T; i++) {
            if (a.charAt(i)=='0')
                zeros++;
            else ones++;
        }

        if (zeros==ones)
            System.out.print(a.substring(0,T-2) + " " + a.charAt(T-1));
        else System.out.println(a);
    }
}

class FastScanner {
    public int BS = 1<<16;
    public char NC = (char)0;
    byte[] buf = new byte[BS];
    int bId = 0, size = 0;
    char c = NC;
    double num = 1;
    BufferedInputStream in;

    public FastScanner() {
        in = new BufferedInputStream(System.in, BS);
    }

    public FastScanner(String s) {
        try {
            in = new BufferedInputStream(new FileInputStream(new File(s)), BS);
        }
        catch (Exception e) {
            in = new BufferedInputStream(System.in, BS);
        }
    }

    public char nextChar(){
        while(bId==size) {
            try {
                size = in.read(buf);
            }catch(Exception e) {
                return NC;
            }
            if(size==-1)return NC;
            bId=0;
        }
        return (char)buf[bId++];
    }

    public int nextInt() {
        return (int)nextLong();
    }

    public long nextLong() {
        num=1;
        boolean neg = false;
        if(c==NC)c=nextChar();
        for(;(c<'0' || c>'9'); c = nextChar()) {
            if(c=='-')neg=true;
        }
        long res = 0;
        for(; c>='0' && c <='9'; c=nextChar()) {
            res = (res<<3)+(res<<1)+c-'0';
            num*=10;
        }
        return neg?-res:res;
    }

    public double nextDouble() {
        double cur = nextLong();
        return c!='.' ? cur:cur+nextLong()/num;
    }

    public String next() {
        StringBuilder res = new StringBuilder();
        while(c<=32)c=nextChar();
        while(c>32) {
            res.append(c);
            c=nextChar();
        }
        return res.toString();
    }

    public String nextLine() {
        StringBuilder res = new StringBuilder();
        while(c<=32)c=nextChar();
        while(c!='\n') {
            res.append(c);
            c=nextChar();
        }
        return res.toString();
    }

    public boolean hasNext() {
        if(c>32)return true;
        while(true) {
            c=nextChar();
            if(c==NC)return false;
            else if(c>32)return true;
        }
    }

    public int[] nextIntArray(int n) {
        int[] res = new int[n];
        for(int i = 0; i < n; i++) res[i] = nextInt();
        return res;
    }

    public char[] nextCharArray(int n) {
        char[] res = new char[n];
        for (int i = 0; i < n; i++) {
            res[i] = nextChar();
        }
        return res;
    }

}

import java.util.*;
public class Main {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        ArrayList<String> arrayList=new ArrayList<>();
        int n=scan.nextInt();
        String str=scan.next();
        char arraystr[]=str.toCharArray();
        int sum0=0;
        int sum1=0;
        for (int i=0;i<n;i++){
            if(arraystr[i]=='0'){
                sum0++;
            }
            else {
                sum1++;
            }
        }
        if (sum0==sum1){
            System.out.print(2);
            System.out.print(str.charAt(0)+" ");
            for (int i=1;i<n;i++){
                System.out.print(str.charAt(i));
            }
        }
        else {
            System.out.println(1);
            System.out.println(str);
        }

    }
}

import java.util.Scanner;

public class que1 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner scn=new Scanner(System.in);
		String s=scn.next();
		mt(s);

	}

	public static void mt(String s) {
		if (s.length() == 1) {
			System.out.println(1);
			System.out.println(s);
			return;
		}
		int t0 = 0, t1 = 0;
		for (int i = 0; i < s.length(); i++) {
			int l = s.charAt(i) - '0';
			if (l == 0) {
				t0++;
			} else {
				t1++;
			}
		}
		int zy = 0, oy = 0;
		for (int i = 0; i < s.length(); i++) {
			int l = s.charAt(i) - '0';
			if (l == 0) {
				zy++;
			} else {
				oy++;
			}
			if (zy != oy && (t0 - zy != t1 - oy)) {
				String s1 = s.substring(0, i + 1);
				String s2 = s.substring(i + 1);
				System.out.println(2);
				System.out.println(s1 + " " + s2);
				break;
			}
		}
	}
}

import java.util.Scanner;
public class p1189a
{
	public static void main(String[] args) {
		Scanner s = new Scanner(System.in);
		int n=s.nextInt();
		String s1=s.next();
		char[] c= s1.toCharArray();
		int count=0,cc=0;
		int length=c.length;
		for(int i=0;i<length;i++)
		{
			if(c[i]=='0')
			{
				count++;
			}
			else
			{
				cc++;
			}
		}
		System.out.println(n/cc);
		for(int i=0;i<length/2;i++)
		{
			System.out.print(c[i]);
		}
		System.out.print(" ");
		for(int i=length/2;i<length;i++)
		{
			System.out.print(c[i]);
		}
	}
}

import java.util.Scanner;

public class MainClass {

	public static void main(String args[]) {
		Scanner myObj = new Scanner(System.in);

	    String lengthString = myObj.nextLine();
	    String badString = myObj.nextLine();

	    System.out.println(2);
	    System.out.println(badString.substring(1) + " " + badString.substring(0, 1));
	}

}

import java.util.*;
public class codeforcesContest {
	public static void main(String[] args)
	{
		Scanner sc= new Scanner(System.in);
		int n= sc.nextInt();
		String x=sc.next();
		int one=0,zero=0;
		String first="";
		String second="";
		for(int i=0;i<x.length();i++)
		{
			if(x.charAt(i)=='1')
			{
				one++;
			}
			else
				zero++;
		}
		if(one != zero)
		{
			System.out.println(1);
			System.out.println(x);
			return;
		}
		if(n%2==0)
		{
			System.out.println(2);
			System.out.println(x.substring(0,x.length()/2) + " "+ x.substring(x.length()/2));
		}
		else
		{
			for(int i=0;i<x.length();i++)
			{
				System.out.println(2);
				System.out.println(x.charAt(0)+ " "+ x.substring(1));
			}
		}

	}

}

import java.util.Scanner;

public class KeanuReeves {

	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		int k=scan.nextInt();
		scan.nextLine();
		String s=scan.nextLine();
		int n=s.length();
		int c=0,d=0;
		String t1="";
		String t2="";
		if(n>1)
		{
			for(int i=0;i<n/2;i++)
			{
				t1=t1+s.charAt(i); c=1;
			}
			for(int i=n/2;i<n;i++)
			{
				t2=t2+s.charAt(i); d=1;
			}
			System.out.println(c+d);
			System.out.println(t1+" "+t2);
		}
		if(n==1) System.out.println(n);
	}

}

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

public class code {

	/**
	 * @param args
	 */
	public static PrintWriter out = new PrintWriter(System.out);

	public static void main(String[] args) throws Exception
	{
		// TODO Auto-generated method stub

		 BufferedReader br=new BufferedReader(new InputStreamReader(System.in));

	        	int n = Integer.parseInt(br.readLine());
	        	String s = br.readLine().trim();
	        	out.println(n);
	        	char[]a = s.toCharArray();
	        	if(n%2!=0)
	        	{
	        		out.println("1");
	        		out.println(new String(a));
	        	}
	        	else
	        	{
	        		int z,o;
	        		z=0;
	        		o=0;

	        		for(int i=0;i<a.length;i++)
	        		{
	        			if(a[i]=='0')
	        				z++;
	        			else
	        				o++;

	        			if((z+o)%2!=0)
	        			{
	        				out.println("2");
	        				out.print(s.substring(0,i+1)+" "+s.substring(i+1,a.length));
	        				break;
	        			}
	        		}

	        	}

	        out.close();
	}

}

import java.util.Scanner;

public class mainClass {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        String s = sc.next();
        int one = 0;
        int zero = 0;

        for (int i = 0; i < n; i++) {
            if(s.charAt(i)=='1'){
                one++;
            }else {
                zero++;
            }
        }

        if(n%2==1 || n==one || n==zero){
            System.out.println(1);
            System.out.println(s);
        }else {
            System.out.println(2);
            System.out.println(s.substring(0,s.length()-1)+" "+s.charAt(s.length()-1));

        }

    }
}

import java.util.Scanner;

public class KeanuReeves {

	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		int k=scan.nextInt();
		scan.nextLine();
		String s=scan.nextLine();
		int n=s.length();
		int c=0,d=0;
		String t1="";
		String t2="";
		if(n>1)
		{
			for(int i=0;i<n/2;i++)
			{
				t1=t1+s.charAt(i); c=1;
			}
			for(int i=n/2;i<n;i++)
			{
				t2=t2+s.charAt(i); d=1;
			}
			System.out.println(c+d);
			System.out.println(t1+" "+t2);
		}
	}

}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Scanner;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author Shahab
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        Scanner in = new Scanner(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskA solver = new TaskA();
            solver.solve(1, in, out);
        out.close();
    }

    static class TaskA {
        public void solve(int testNumber, Scanner in, PrintWriter out) {
            int n = in.nextInt();
            String s = in.next();

            if (isGood(s)) {
                out.println("1");
                out.println(s);
            } else {
                out.println("2");
                out.print(s.substring(0, s.length() - 1));
                out.println(s.charAt(s.length() - 1));
            }
        }

        private boolean isGood(String s) {
            int cnt1 = 0;
            int cnt0 = 0;

            for (int i = 0; i < s.length(); i++) {
                if (s.charAt(i) == '1') cnt1++;
                else cnt0++;
            }

            return cnt0 != cnt1;
        }

    }
}

import java.io.*;

public class test{
    public static void main(String[] args) {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        try {
            int n = Integer.parseInt(br.readLine());
            String s = br.readLine();
            if(n%2==0) {
                System.out.println(2);
                System.out.println(s.substring(0,s.length()-1) + " " + s.substring(s.length()-1));
            }else {
                System.out.println(1);
                System.out.println(s);
            }
            return;
        } catch (Exception e) {
            return;
        }
    }
}

import java.util.ArrayList;
import java.util.Scanner;

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
/**
 *
 * @author anhnth37
 */
public class A_1189 {

    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int n = input.nextInt();
        String s = input.next();

        if (checkEqual(n, s)) {
            int t = n / 2;
            String s1 = "";
            String s2 = "";
            do {
                s1 = s.substring(0, t);
                s2 = s.substring(t);
                t++;
            } while (checkEqual(s1.length(), s1) && checkEqual(s2.length(), s2));

            System.out.println(s1 + " " + s2);
        } else {
            System.out.println("1");
            System.out.println(s);
        }
    }

    public static boolean checkEqual(int n, String s) {
        int countZero = 0;
        int countOne = 0;
        for (int i = 0; i < n; i++) {
            if (s.charAt(i) == '0') {
                countZero++;
            } else {
                countOne++;
            }
        }
        return countZero == countOne;
    }
}

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

public class test
{
     public static void main(String args[])throws IOException
     {

		String s;
		int a, count0=0, count1=0, i;
		Scanner s1 = new Scanner(System.in);
		a = s1.nextInt();
		char arr[] = new char[a];
		s1.nextLine();
		s = s1.nextLine();

		arr = s.toCharArray();

        /*for(i = 0; i < a; i++)
        {
        	if(arr[i] == '0')
        		count0++;
        	else
        		count1++;
        } */
        if(a == 1)
        	{
        		System.out.println("1");
                System.out.println(arr[0]);
        	}
        else
        {
        	System.out.println("2");

            for(i = 0; i < a-1; i++)
        	System.out.print(arr[i]);

            System.out.print(" " + arr[a-1]);
        }

       }
}

import java.util.Scanner;

public class CutStrings {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int lengthOfStr = in.nextInt();
        String givenStr = in.next();
        if(lengthOfStr%2 == 1) {
           System.out.println(1);
           System.out.println(givenStr);
        } else {
            System.out.println(2);
            System.out.println(givenStr.substring(0,lengthOfStr/2) + " " + givenStr.substring(lengthOfStr/2));
        }
    }
}

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

public class Codechef
{
	public static void main(String args[]) throws NumberFormatException, IOException
	{
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));

		int n=Integer.parseInt(br.readLine());
		String str=br.readLine();

			if(n%2!=0)
			{
				System.out.println(1);
			for(int i=0;i<n;i++)
			{
				System.out.print(str.charAt(i));
			}
			System.out.println();
			}
			else
			{
				System.out.println(2);
				System.out.print(str.charAt(0)+" ");
				for(int i=1;i<n;i++)
				{
					System.out.print(str.charAt(i));
				}
				System.out.println();
			}
		}

}

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
 public class Acm {
public static void main (String args[]){
Scanner sc = new Scanner ();
sc.nextInt();
String s =sc.nextToken();
String r ="";
int p = 1 ;
boolean f = false ;
while (!isgood(s)||!f){
	p++;f=true;
r+=s.charAt(0)+" ";
String k = s;
	s= "";
	for (int i = 1; i<k.length();i++)
		s+=(k.charAt(i)+"");

}
System.out.println(p);
System.out.println(r+s);

}
public static boolean isgood (String s ){
	int z =0;
	int o=0;
	for (int i = 0;i<s.length();i++)
		if (s.charAt(i)=='0')z++;
		else o++;
	if (z==o&&z!=0&&o!=0)return false ;
	else return true ;
}
}

/*
for (int h = 0 ;h<n ;h++){

}
*/

 class Scanner {
		BufferedReader br;
		StringTokenizer st;

		public Scanner(String s) {
			try {
				br = new BufferedReader(new FileReader(s));
			} catch (FileNotFoundException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}

		public Scanner() {
			br = new BufferedReader(new InputStreamReader(System.in));
		}

		String nextToken() {
			while (st == null || !st.hasMoreElements()) {
				try {
					st = new StringTokenizer(br.readLine());
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			return st.nextToken();
		}

		int nextInt() {
			return Integer.parseInt(nextToken());
		}

		long nextLong() {
			return Long.parseLong(nextToken());
		}

		double nextDouble() {
			return Double.parseDouble(nextToken());
		}
	}

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

public class Main {
    public static void main(String[] args) throws IOException {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        InputReader.OutputWriter out = new InputReader.OutputWriter(outputStream);

        int n = in.nextInt();
        String s = in.next();
        int zeroes = 0;
        int ones = 0;
        for (int i = 0; i < s.length(); i++) {
            if(s.charAt(i) == '0') zeroes++;
            else ones++;
        }
        if(n == 1) {
            out.println(1);
            out.println(s);
        }
        else {
            if(ones == zeroes) {
                out.println(2);
                out.println(s.substring(0,1) + " " + s.substring(1));
            }
            else {
                out.println(2);
                out.println(s.substring(0,2) + " " + s.substring(2));
            }
        }

        out.flush();
    }
}

class InputReader extends BufferedReader {
    StringTokenizer tokenizer;

    public InputReader(InputStream inputStream) {
        super(new InputStreamReader(inputStream), 32768);
    }

    public InputReader(String filename) {
        super(new InputStreamReader(Thread.currentThread().getContextClassLoader().getResourceAsStream(filename)));
    }

    public String next() {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
            try {
                tokenizer = new StringTokenizer(readLine());
            } catch (IOException e) {
                throw new RuntimeException();
            }
        }
        return tokenizer.nextToken();
    }

    public Integer nextInt() {
        return Integer.valueOf(next());
    }
    public Long nextLong() {return  Long.valueOf(next());}

    static class OutputWriter extends PrintWriter {
        public OutputWriter(OutputStream outputStream) {
            super(outputStream);
        }

        public OutputWriter(Writer writer) {
            super(writer);
        }

        public OutputWriter(String filename) throws FileNotFoundException {
            super(filename);
        }

        public void close() {
            super.close();
        }
    }
}

import java.util.Scanner;

public class CutStrings {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int lengthOfStr = in.nextInt();
        String givenStr = in.next();
        if(lengthOfStr%2 == 1) {
           System.out.println(1);
           System.out.println(givenStr);
        } else {
            System.out.println(2);
            System.out.println(givenStr.substring(0,1) + " " + givenStr.substring(1));
        }
    }
}

import java.util.HashSet;
import java.util.Scanner;

public class Main1189A {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while (in.hasNext()) {
            int n = in.nextInt();
            String s = in.next();

            if (n % 2 == 1) {
                System.out.println(s);
            } else {
                if (isSame(s)) {
                    System.out.println(s);
                } else {
                    System.out.println(s.charAt(0) + " " + s.substring(1));
                }
            }
        }
    }

    public static boolean isSame(String s) {
        HashSet<Character> set = new HashSet<>();
        char[] ch = s.toCharArray();
        for (char c : ch) {
            set.add(c);
        }
        return set.size() == 1;
    }

}

import java.util.*;
public class Q1
{
	public static void main(String[]args)
	{
		Scanner sc = new Scanner(System.in);
		//int t = sc.nextInt();
		int n = sc.nextInt();
		String str = sc.next();
		String [] ch = str.split("");
		int [] arr = new int[n];
		for(int i=0;i<n;i++)
		{
			arr[i] = Integer.parseInt(ch[i]);
		}
		Arrays.sort(arr);
		for(int i=0;i<n/2;i++)
		{
			if(i!=n/2-1)
			{
				System.out.print(arr[i]+"");
			}
			else
			{
				System.out.print(arr[i]+ " ");
			}
		}
		for(int i=n/2;i<n;i++)
		{
			if(i!=n-1)
			{
				System.out.print(arr[i]+"");
			}
			else
			{
				System.out.println(arr[i]);
			}
		}

	}
}

import java.util.Scanner;

public class A1189 {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int N = in.nextInt();
        String S = in.next();
        if (N%2 == 0) {
            System.out.println("2");
            System.out.println(S.charAt(0) + " " + S.substring(1));
        } else {
            System.out.println("1");
            System.out.println(S);
        }
    }

}

import java.util.Scanner;
public class A{
    static int count(char a,String list ){
        int res=0;
        for (int i=0;i<list.length();i++){
            if (list.charAt(i)==a){
                res=res+1;
            }
        }
        return res;
    }
    public static void main(String args[]){
        Scanner in=new Scanner(System.in);
        int n=in.nextInt();
        int res=0;
        String list= in.next();
        if (count('1',list)!=count('0',list)){
            System.out.println(1);
            res=1;
        }
        else if (n>1){
        System.out.println(2);}
        else{
            res=1;
            System.out.println(1);
        }
        if (res!=1){

        System.out.print(list.charAt(0));
        System.out.print(" ");
        for (int i=0;i<list.length()-1;i++){
            System.out.print(list.charAt(i));}}
        else{
            System.out.println(list);
        }
}
}

import java.util.Scanner;

public class Solution {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);

        int n = in.nextInt();
        String s = in.next();

        int zeros = 0;
        for (int i = 0; i < s.length(); i++) {
            if (s.charAt(i) == '0') zeros++;
        }

        if (zeros * 2 == s.length()) {
            System.out.println(1);
            System.out.println(s);
        } else {
            System.out.println(2);
            System.out.print(s.charAt(0));
            System.out.print(" " + s.substring(1));
        }
    }

}

import java.util.*;
public class codeforces3_1 {
	public static void main(String[] args) {
		int n, numOfZeros = 0, numOfOnes = 0;
		String s;
		Scanner sc = new Scanner(System.in);
		n = sc.nextInt();
		s = sc.next();
		for (int i = 0; i < n; i++) {
			if (s.charAt(i) == '0') {
				numOfZeros++;
			} else {
				numOfOnes++;
			}
		}
		int stringOneNumOfZeros = 0, stringOneNumOfOnes = 0, stringTwoNumOfZeros = numOfZeros,
				stringTwoNumOfOnes = numOfOnes;
		int x = 0;
		if (n == 1) {
			System.out.println("1");
			System.out.print(s);
		} else {
			for (int i = 0; i < s.length(); i++) {
				if (stringOneNumOfZeros != stringOneNumOfOnes && stringTwoNumOfZeros != stringTwoNumOfOnes) {
					x = i;
					break;
				}
				if (s.charAt(i) == '0') {
					stringOneNumOfZeros++;
					stringTwoNumOfZeros--;
				} else {
					stringOneNumOfZeros++;
					stringTwoNumOfOnes--;
				}
			}
			System.out.println("2");
			System.out.print(s.substring(0, x));
			System.out.print(" ");
			System.out.print(s.substring(x, n));
		}
	}
}

import java.util.Scanner;
import java.util.HashMap;
import java.util.Scanner;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Queue;
public class Codepractis {

    public static void main(String[] args) {

        Scanner scan=new Scanner(System.in);

        int n = scan.nextInt();
        String str = scan.next();
         String s = "";
         int count1=0;
         int count0=0;
         int cut = 0 ;

           for (int i = 0; i <str.length(); i++) {
             if(str.charAt(i)=='1')
                  count1++;

             if(str.charAt(i)=='0')
                 count0++;
             }

             if(count0!=count1||count1==0||count0==0){
                 System.out.println("1");
                 System.out.println(str);
                 return;
             }
             count0=0;
             count1=0;
             boolean is = true;
             String s2 ="";
             for (int i = 0; i <str.length(); i++) {

                 if(str.charAt(i)=='0'&&is){
                     s+='0';
                     count0++;
                 }
                 else if(is&&str.charAt(i)=='1'&&is){
                     s+='1';
                 count1++;

             }
                  if(i>=str.length()/2&&count0!=count1&&is){
                     is=false;

                 }
                  else if(!is){
                    s2+=str.charAt(i);
                  }

             }
             System.out.println("2");
             System.out.println(s+" "+s2);

    }

        }

import java.util.Scanner;

public class MainClass {

	@SuppressWarnings("unlikely-arg-type")
	public static void main(String args[]) {
		Scanner myObj = new Scanner(System.in);

	    String lengthString = myObj.nextLine();
	    String badString = myObj.nextLine();
	    int length = Integer.valueOf(lengthString);

	    int j = 0;
	    for (int i = 0; i < length; i++) {
	    	if ("1".equals(Character.toString(badString.charAt(i)))) {
	    		j++;
	    	}
	    }

	    if (length % 2 ==0 && j == length /2) {
	    	printBad(badString);
	    } else {
	    	printGood(badString);
	    }
	}

	private static void printGood(String goodString) {
		System.out.println(1);
	    System.out.println(goodString);
	}

	private static void printBad(String badString) {
		System.out.println(2);
	    System.out.println(badString.substring(1) + " " + badString.substring(0, 1));
	}
}

import java.util.HashSet;
import java.util.Scanner;

public class Main1189A {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while (in.hasNext()) {
            int n = in.nextInt();
            String s = in.next();

            if (n % 2 == 1) {
                System.out.println(1);
                System.out.println(s);
            } else {
                System.out.println(2);
                if (isSame(s)) {
                    System.out.println(s);
                } else {
                    System.out.println(s.charAt(0) + " " + s.substring(1));
                }
            }
        }
    }

    public static boolean isSame(String s) {
        HashSet<Character> set = new HashSet<>();
        char[] ch = s.toCharArray();
        for (char c : ch) {
            set.add(c);
        }
        return set.size() == 1;
    }

}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {
	public static void main(String[] args) throws NumberFormatException, IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

		int n = Integer.parseInt(br.readLine());
		String str = br.readLine();

		int count0 = 0;
		int count1 = 0;
		for(int i=0; i<n; i++) {
			if(str.charAt(i) == '0') ++count0;
			else if(str.charAt(i) == '1') ++count1;
		}

		if(count0 == count1) {
			System.out.println(1);
			System.out.println(str);
		} else {
			System.out.println(2);
			System.out.print(str.substring(0, 1));
			System.out.println(str.substring(1));
		}
	}
}

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

public class june5_3
{

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

		FastReader scan=new FastReader();
		 int n=scan.nextInt();
		 String s=scan.next();
		 int count1=0;
		 int count0=0;
		 int min=Integer.MAX_VALUE;
		 for(int i=0;i<n;i++){
			if(s.charAt(i)=='0') count0++;
			else count1++;
		 }
		 if(count1!=count0) System.out.println("1");
		 else{
			 String ans="";
			 ans+=s.charAt(0);
			 ans+=" ";
			 ans+=s.substring(1, n);
			 System.out.println(ans);
		 }
	}

		 static class FastReader{
	          BufferedReader in;
	          StringTokenizer st;
	          public FastReader(){
	              in=new BufferedReader(new InputStreamReader(System.in));
	          }
	          String next(){
	              while(st==null || !st.hasMoreElements()){
	                  try{
	                      st=new StringTokenizer(in.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 str19 = "";
	            try{
	                str19 = in.readLine();
	            }
	            catch (IOException e){
	                e.printStackTrace();
	             }
	            return str19;
	        }
	      }
	}

import java.util.Scanner;
import java.util.HashMap;
import java.util.Scanner;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Queue;
public class Codepractis {

    public static void main(String[] args) {

        Scanner scan=new Scanner(System.in);

        int n = scan.nextInt();
        String str = scan.next();
         String s = "";
         int count1=0;
         int count0=0;
         int cut = 0 ;

            if(str.length()==2&&str.charAt(0)!=str.charAt(1)){
                System.out.println("1");
                System.out.println(str.charAt(0)+" "+str.charAt(1));
                return;
            }
           for (int i = 0; i <str.length(); i++) {
             if(str.charAt(i)=='1')
                  count1++;

             if(str.charAt(i)=='0')
                 count0++;
             }

             if(count0!=count1||count1==0||count0==0){
                 System.out.println("1");
                 System.out.println(str);
                 return;
             }
             count0=0;
             count1=0;
             boolean is = true;
             String s2 ="";
             for (int i = 0; i <str.length(); i++) {

                 if(str.charAt(i)=='0'&&is){
                     s+='0';
                     count0++;
                 }
                 else if(is&&str.charAt(i)=='1'&&is){
                     s+='1';
                 count1++;

             }
                  if(i>=str.length()/2&&count0!=count1&&is){
                     is=false;

                 }
                  else if(!is){
                    s2+=str.charAt(i);
                  }

             }
             System.out.println("2");
             System.out.println(s+" "+s2);

    }

        }

//package hiougyf;
import java.io.*;
import java.util.*;

public class Solution {
	  public static void main(String[] args) throws IOException
	    {
		 Scanner sc =new Scanner(System.in);
		 int n=sc.nextInt();
		String s=sc.next();
		int ans=0;
		int a=0,b=0;
		for(int i=0;i<n;i++) {
			char t=s.charAt(i);
			if(t=='0') {
				a++;
				continue;
			}
			if(t=='1') {
				b++;
				continue;
			}
		}
				if(a!=b) System.out.println(s);
				else {
					System.out.println(s.substring(0,n-1)+" "+s.charAt(n-1));
				}

	    }

	  public static int floorSqrt(int x)
	    {
	        // Base Cases
	        if (x == 0 || x == 1)
	            return x;

	        // Do Binary Search for floor(sqrt(x))
	        int start = 1, end = x, ans=0;
	        while (start <= end)
	        {
	            int mid = (start + end) / 2;

	            // If x is a perfect square
	            if (mid*mid == x)
	                return mid;

	            // Since we need floor, we update answer when mid*mid is
	            // smaller than x, and move closer to sqrt(x)
	            if (mid*mid < x)
	            {
	                start = mid + 1;
	                ans = mid;
	            }
	            else   // If mid*mid is greater than x
	                end = mid-1;
	        }
	        return ans;
	    }
		static int div(int n,int b) {
			int g=-1;
			for(int i=2;i<=Math.sqrt(n);i++) {
				if(n%i==0&&i!=b) {
					g=i;
					break;
				}
			}
			return g;
		}

	  public static int gcd(int a, int b)
	    {
	        if (a == 0)
	            return b;

	        return gcd(b%a, a);
	    }
	   public static int lcm(int a, int b)
	  {
	     return (a*b)/gcd(a, b);
	  }
	   public static boolean isPrime1(int n) {
           if (n <= 1) {
               return false;
           }
           if (n == 2) {
               return true;
           }
           for (int i = 2; i <= Math.sqrt(n) + 1; i++) {
               if (n % i == 0) {
                   return false;
               }
           }
           return true;
       }
       public static boolean isPrime(int n) {
           if (n <= 1) {
               return false;
           }
           if (n == 2) {
               return true;
           }
           if (n % 2 == 0) {
               return false;
           }
           for (int i = 3; i <= Math.sqrt(n) + 1; i = i + 2) {
               if (n % i == 0) {
                   return false;
               }
           }
           return true;
       }

}

import java.util.*;
public class div572{
	public static void main(String s[]){
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		String st = sc.next();
		int one=0;
		int zero=0;
		for(int i=0;i<st.length();i++){
			if(st.charAt(i)=='0')
				zero++;
			else one++;
		}
		if(zero!=one){
			System.out.println("1");
			for(int i=0;i<n;i++){
				System.out.print(st.charAt(i)+" ");
			}
			System.out.println();
			return;
		}else{
			int index=-1;
			System.out.print(st.substring(0,n-1)+" "+st.substring(n-1));
			System.out.println();
		}
	}
}

import java.util.*;
public class Solution {

    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        String s = scan.next();
        //System.out.println(s);
        s = sortString(s);
        int count1 = 0,count0 = 0;
        for(int i=0;i<s.length();i++) {
            if(s.charAt(i)=='1')
                count1++;
            else if(s.charAt(i)=='0')
                count0++;
        }

        if(count1!=count0) {
            System.out.println(1);
            System.out.println(s);
        }
        else {
            System.out.println(2);
            String s1 = "",s2 = "";
            for(int i=0;i<s.length();i++) {
                if(s.charAt(i)=='0') {
                    s1+=s.charAt(i);
                }
                if(s.charAt(i)=='1') {
                    s2+=s.charAt(i);
                }
            }
            System.out.print(s1+" "+s2);
        }
    }
    public static String sortString(String inputString)
    {
        // convert input string to char array
        char tempArray[] = inputString.toCharArray();

        // sort tempArray
        Arrays.sort(tempArray);

        // return new sorted string
        return new String(tempArray);
    }
}

import java.sql.Array;
import java.util.*;

public class Main {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        scanner.nextLine();
        String inputString = scanner.nextLine();
        if(inputString.length() == 1) {
            //for 1
            System.out.println(1);
            System.out.println(inputString);
        } else if (inputString.length() == 2) {
            //for 2
            System.out.println(2);
            System.out.println(inputString.charAt(0) + " " + inputString.charAt(1));
        } else if (isGood(inputString)){
            //for good
            System.out.println(1);
            System.out.println(inputString);
        } else if (inputString.length() % 2 == 0) {
            //even
            if (isGood(inputString.substring(inputString.length() / 2 )) && isGood(inputString.substring(0, inputString.length() / 2))) {
                System.out.println(2);
                System.out.println(inputString.substring(0, inputString.length() / 2) + " " + inputString.substring(inputString.length() / 2));
            } else {
                System.out.println(2);
                System.out.println(inputString.substring(0, inputString.length() / 2 - 1) + " " + inputString.substring(inputString.length() / 2 - 1));
            }
        } else {
            //odd
//            System.out.println("odd");
            int i = 0;
            while (i < inputString.length() / 2 && ! (isGood(inputString.substring(inputString.length() / 2 - 1 + i)) && isGood(inputString.substring(0, inputString.length() / 2 - 1 + i)))) {
                i += 1;
            }
//            System.out.println(i);
            if (i == inputString.length() / 2) {
                System.out.println(3);
                System.out.println(inputString.substring(0, inputString.length() - 2)
                        + " " + inputString.substring(inputString.length() - 2, inputString.length() - 1)
                        + " " + inputString.substring(inputString.length() - 1) );

            }
        }
//        System.out.println(x*2);
    }

    public static boolean isGood (String str) {
        String findStr0 = "0";
        String findStr1 = "1";
        int lastIndex = 0;
        int count0 = 0;
        int count1 = 0;

        while(lastIndex != -1){

            lastIndex = str.indexOf(findStr0,lastIndex);

            if(lastIndex != -1){
                count0 ++;
                lastIndex += findStr0.length();
            }
        }
        lastIndex = 0;

        while(lastIndex != -1){

            lastIndex = str.indexOf(findStr1,lastIndex);

            if(lastIndex != -1){
                count1 ++;
                lastIndex += findStr1.length();
            }
        }
//        System.out.println(count0 + " " + count1);
        return count0 != count1;
    }
}