Dima worked all day and wrote down on a long paper strip his favorite number n consisting of l digits. Unfortunately, the strip turned out to be so long that it didn't fit in the Dima's bookshelf.

To solve the issue, Dima decided to split the strip into two non-empty parts so that each of them contains a positive integer without leading zeros. After that he will compute the sum of the two integers and write it down on a new strip.

Dima wants the resulting integer to be as small as possible, because it increases the chances that the sum will fit it in the bookshelf. Help Dima decide what is the minimum sum he can obtain.

Input

The first line contains a single integer l (2 ≤ l ≤ 100 000) — the length of the Dima's favorite number.

The second line contains the positive integer n initially written on the strip: the Dima's favorite number.

The integer n consists of exactly l digits and it does not contain leading zeros. Dima guarantees, that there is at least one valid way to split the strip.

Output

Print a single integer — the smallest number Dima can obtain.

Examples

Input


7
1234567


Output


1801


Input


3
101


Output


11

Note

In the first example Dima can split the number 1234567 into integers 1234 and 567. Their sum is 1801.

In the second example Dima can split the number 101 into integers 10 and 1. Their sum is 11. Note that it is impossible to split the strip into "1" and "01" since the numbers can't start with zeros.
import java.util.*;
import java.io.*;
import java.math.*;
public class a{
	static void add(String a,String b){
		int i=a.length()-1,j=b.length()-1;
		int carry=0;
		StringBuilder ans=new StringBuilder("");

		while(i>=0 || j>=0){
			int sum=carry;
			if(i>=0)
				sum+=(a.charAt(i)-'0');
			
			if(j>=0)
				sum+=(b.charAt(j)-'0');

			ans.append(sum%10);
			carry=sum/10;
			i--;j--;
		}
		System.out.println(ans.reverse().toString());
	}
	public static void main( String [] args) throws IOException{
	BufferInput sc=new BufferInput();
	int l=sc.nextInt();
	String s=sc.next();

	int mid=l/2;

	if(s.charAt(mid)=='0'){
		int i=mid,j=mid;
		while(i>=0 && s.charAt(i)=='0')i--;
		while(j<l && s.charAt(j)=='0')j++;

		if(i>0 && j<l){
			BigInteger a=new BigInteger(s.substring(0,i));
			BigInteger b=new BigInteger(s.substring(i,l));
			BigInteger s1=a.add(b);

			BigInteger c=new BigInteger(s.substring(0,j));
			BigInteger d=new BigInteger(s.substring(j,l));
			BigInteger s2=c.add(d);

			BigInteger min=s1.min(s2);

			System.out.println(min);
		}
		else if(i==0){
			BigInteger c=new BigInteger(s.substring(0,j));
			BigInteger d=new BigInteger(s.substring(j,l));
			BigInteger s2=c.add(d);
			System.out.println(s2);
		}
		else {
			BigInteger a=new BigInteger(s.substring(0,i));
			BigInteger b=new BigInteger(s.substring(i,l));
			BigInteger s1=a.add(b);
			System.out.println(s1);
		}
		


	}
	else{
		if(l%2!=0){
			BigInteger a=new BigInteger(s.substring(0,mid));
			BigInteger b=new BigInteger(s.substring(mid,l));
			BigInteger s1=a.add(b);

			BigInteger c=new BigInteger(s.substring(0,mid+1));
			BigInteger d=new BigInteger(s.substring(mid+1,l));
			BigInteger s2=c.add(d);

			BigInteger min=s1.min(s2);

			System.out.println(min);
		}
		else{
			
			BigInteger a=new BigInteger(s.substring(0, mid));
			BigInteger b=new BigInteger(s.substring(mid, l));
			BigInteger sum=a.add(b);
			System.out.println(sum);

		}
	}

	


	

	


  }
}




























































































class BufferInput{	
	 private int BUFFER_SIZE = 1 << 16;
	
	private  DataInputStream din;
	
	private  byte[] buffer;
	
	private int bufferPointer, bytesRead;
	
	public BufferInput() {
		din = new DataInputStream(System.in);
		buffer = new byte[BUFFER_SIZE];
		bufferPointer = bytesRead = 0;
	}

	public BufferInput( String file_name) throws IOException {
		din = new DataInputStream(new FileInputStream(file_name));
		buffer = new byte[BUFFER_SIZE];
		bufferPointer = bytesRead = 0;
    }
    
	public String readLine() throws IOException {
		 byte[] buf = new byte[64];
		int cnt = 0, c;
		while ((c = read()) != -1) {
			if (c == '\n')
				break;
			buf[cnt++] = (byte) c;
		}
		return new String(buf, 0, cnt);
	}
    
    public String next() throws IOException{

		byte c = read();
		while(Character.isWhitespace(c)){
			c = read();
		}
		
		 StringBuilder builder = new StringBuilder();
		builder.append((char)c);
		c = read();
		while(!Character.isWhitespace(c)){
			builder.append((char)c);
			c = read();
		}
		
		return builder.toString();
	}

	public int nextInt() throws IOException {
		int ret = 0;
		byte c = read();
		while (c <= ' ')
			c = read();
		 boolean neg = (c == '-');
		if (neg)
			c = read();
		do {
			ret = ret * 10 + c - '0';
		} while ((c = read()) >= '0' && c <= '9');

		if (neg)
			return -ret;
		return ret;
	}
	
	public int[] nextIntArray( int n) throws IOException {
		 int arr[] = new int[n];
		for(int i = 0; i < n; i++){
			arr[i] = nextInt();
		}
		return arr;
	}

	public long nextLong() throws IOException {
		long ret = 0;
		byte c = read();
		while (c <= ' ')
			c = read();
		 boolean neg = (c == '-');
		if (neg)
			c = read();
		do {
			ret = ret * 10 + c - '0';
		} while ((c = read()) >= '0' && c <= '9');
		if (neg)
			return -ret;
		return ret;
	}
	
	public long[] nextLongArray( int n) throws IOException {
		 long arr[] = new long[n];
		for(int i = 0; i < n; i++){
			arr[i] = nextLong();
		}
		return arr;
	}

	public char nextChar() throws IOException{
		byte c = read();
		while(Character.isWhitespace(c)){
			c = read();
		}
		return (char) c;	
	}
	
	public double nextDouble() throws IOException {
		double ret = 0, div = 1;
		byte c = read();
		while (c <= ' ')
			c = read();
		 boolean neg = (c == '-');
		if (neg)
			c = read();

		do {
			ret = ret * 10 + c - '0';
		} while ((c = read()) >= '0' && c <= '9');

		if (c == '.') {
			while ((c = read()) >= '0' && c <= '9') {
				ret += (c - '0') / (div *= 10);
			}
		}

		if (neg)
			return -ret;
		return ret;
    }
    
	public double[] nextDoubleArray( int n) throws IOException {
		 double arr[] = new double[n];
		for(int i = 0; i < n; i++){
			arr[i] = nextDouble();
		}
		return arr;
	}

	private void fillBuffer() throws IOException {
		bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
		if (bytesRead == -1)
			buffer[0] = -1;
	}

	private byte read() throws IOException {
		if (bufferPointer == bytesRead)
			fillBuffer();
		return buffer[bufferPointer++];
	}

	public void close() throws IOException {
		if (din == null)
			return;
		din.close();
	}

}


