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 sys, os, io
def rs(): return sys.stdin.readline().rstrip()
def ri(): return int(sys.stdin.readline())
def ria(): return list(map(int, sys.stdin.readline().split()))
def ws(s): sys.stdout.write(s + '\n')
def wi(n): sys.stdout.write(str(n) + '\n')
def wia(a): sys.stdout.write(' '.join([str(x) for x in a]) + '\n')
import math,datetime,functools,itertools,operator,bisect,fractions,statistics
from collections import deque,defaultdict,OrderedDict,Counter
from fractions import Fraction
from decimal import Decimal
from sys import stdout
from heapq import heappush, heappop, heapify ,_heapify_max,_heappop_max

def findSum(str1, str2): 
  
    # Before proceeding further, make sure length 
    # of str2 is larger. 
    if len(str1)> len(str2): 
        temp = str1 
        str1 = str2 
        str2 = temp 
   
    # Take an empty string for storing result 
    str3 = "" 
   
    # Calculate length of both string 
    n1 = len(str1) 
    n2 = len(str2) 
    diff = n2 - n1 
   
    # Initially take carry zero 
    carry = 0
   
    # Traverse from end of both strings 
    for i in range(n1-1,-1,-1): 
      
        # Do school mathematics, compute sum of 
        # current digits and carry 
        
        sum = ((ord(str1[i])-ord('0')) +
                   int((ord(str2[i+diff])-ord('0'))) + carry) 
       
        str3 = str3+str(sum%10 ) 
          
         
        carry = sum//10
   
    # Add remaining digits of str2[] 
    for i in range(n2-n1-1,-1,-1): 
      
        sum = ((ord(str2[i])-ord('0'))+carry) 
        str3 = str3+str(sum%10 ) 
        carry = sum//10
   
    # Add remaining carry 
    if (carry): 
        str3+=str(str(carry)) 
   
    # reverse resultant string 
    str3 = str3[::-1] 
   
    return str3  


def main():
    starttime=datetime.datetime.now()
    if(os.path.exists('input.txt')):
        sys.stdin = open("input.txt","r")
        sys.stdout = open("output.txt","w")

    for _ in range(1):
        n=ri()
        a=list(rs())
        mid=n//2
        if n%2==0:
            mid-=1
        i=mid
        while i>=0:
            if a[i+1] =='0':
                i-=1
            else:
                break
            
        doosra1=a[i+1:]
        pehla1=a[:i+1]
        i=mid
        while i<n-1:
            if a[i+1] =='0':
                i+=1
            else:
                break
        doosra2=a[i+1:]
        pehla2=a[:i+1]
        
        z=[]
        if len(pehla1)!=0:
            z.append([pehla1,doosra1])
        if len(doosra2)!=0:
            z.append([pehla2,doosra2])
        
        
            
        if len(pehla1)==len(pehla2):
            npehla1=pehla1+[doosra1[0]]
            ndoosra1=doosra1[1:]
            npehla2=pehla2[:len(pehla2)-1]
            ndoosra2=[pehla2[len(pehla2)-1]]+doosra2
            if len(npehla1)>0 and len(ndoosra1)>0 and ndoosra1[0]!='0':
                z.append([npehla1,ndoosra1])
            if len(npehla2)>0 and len(ndoosra2)>0 and ndoosra2[0]!='0':
                z.append([npehla2,ndoosra2])
        m=int("9"*n)
        for i in z:
            k=(int(''.join(i[0]))+int(''.join(i[1])))
            # print(''.join(i[0]),''.join(i[1]),k)
            m=min(m,k)
        print(m)
        
         
                
                
            
            
        
        
        
        
                
        
            
        
                
        
        
            
        
       
            

                
        
        
        
   
            
        
        
        
        
            
        
                
        
        
        
            
            
        
        
            
        
        

        
        
            
        
        
            
        
                        

        
        
            
     
        
        
            
        
        
                
            
        
        
        
                
            
        

            
             
        
            
        
        
        
                
        
            
        
        
        
        
                
        
        
            
        
        
        
        
                
        
    #<--Solving Area Ends
    endtime=datetime.datetime.now()
    time=(endtime-starttime).total_seconds()*1000
    if(os.path.exists('input.txt')):
        print("Time:",time,"ms")  
    
                
class FastReader(io.IOBase):
    newlines = 0

    def __init__(self, fd, chunk_size=1024 * 8):
        self._fd = fd
        self._chunk_size = chunk_size
        self.buffer = io.BytesIO()

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, self._chunk_size))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self, size=-1):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, self._chunk_size if size == -1 else size))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()


class FastWriter(io.IOBase):

    def __init__(self, fd):
        self._fd = fd
        self.buffer = io.BytesIO()
        self.write = self.buffer.write

    def flush(self):
        os.write(self._fd, self.buffer.getvalue())
        self.buffer.truncate(0), self.buffer.seek(0)


class FastStdin(io.IOBase):
    def __init__(self, fd=0):
        self.buffer = FastReader(fd)
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")


class FastStdout(io.IOBase):
    def __init__(self, fd=1):
        self.buffer = FastWriter(fd)
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.flush = self.buffer.flush


if __name__ == '__main__':
    sys.stdin = FastStdin()
    sys.stdout = FastStdout()
    main()
    