George is a cat, so he really likes to play. Most of all he likes to play with his array of positive integers b. During the game, George modifies the array by using special changes. Let's mark George's current array as b_1, b_2, ..., b_{|}b| (record |b| denotes the current length of the array). Then one change is a sequence of actions:   Choose two distinct indexes i and j (1 ≤ i, j ≤ |b|; i ≠ j), such that b_{i} ≥ b_{j}.  Get number v = concat(b_{i}, b_{j}), where concat(x, y) is a number obtained by adding number y to the end of the decimal record of number x. For example, concat(500, 10) = 50010, concat(2, 2) = 22.  Add number v to the end of the array. The length of the array will increase by one.  Remove from the array numbers with indexes i and j. The length of the array will decrease by two, and elements of the array will become re-numbered from 1 to current length of the array. 

George played for a long time with his array b and received from array b an array consisting of exactly one number p. Now George wants to know: what is the maximum number of elements array b could contain originally? Help him find this number. Note that originally the array could contain only positive integers.


-----Input-----

The first line of the input contains a single integer p (1 ≤ p < 10^100000). It is guaranteed that number p doesn't contain any leading zeroes.


-----Output-----

Print an integer — the maximum number of elements array b could contain originally.


-----Examples-----
Input
9555

Output
4
Input
10000000005

Output
2
Input
800101

Output
3
Input
45

Output
1
Input
1000000000000001223300003342220044555

Output
17
Input
19992000

Output
1
Input
310200

Output
2


-----Note-----

Let's consider the test examples:   Originally array b can be equal to {5, 9, 5, 5}. The sequence of George's changes could have been: {5, 9, 5, 5} → {5, 5, 95} → {95, 55} → {9555}.  Originally array b could be equal to {1000000000, 5}. Please note that the array b cannot contain zeros.  Originally array b could be equal to {800, 10, 1}.  Originally array b could be equal to {45}. It cannot be equal to {4, 5}, because George can get only array {54} from this array in one operation. 

Note that the numbers can be very large.

Difficulty: interview

Starter code:

Solutions:
s=input().strip()
n=len(s)
i=0
k=1
j=0
while i<n:
    #print(i,j)
    j=i
    i+=1
    while i<n and s[i]=='0':
        i+=1
    if j>i-j:
        k+=1
    elif j==i-j:
        if s[:j]>=s[j:i]:
            k+=1
        else:
            k=1
    else:
        k=1
print(k)

def gte(x, y):
    if len(x)>len(y): return True
    if len(x)==len(y): return x>=y
    return False

x = input()
r = 0
l = len(x)-1
while True:
    if l==0 or not gte(x[:l], x[l:]): break
    if x[l] == '0':
        l-=1
        continue
    x = x[:l]
    r+=1
    l-=1
r+=1
print(r)


a = input()
i = 0
ans = 1
c = 0
while i < len(a):
    i += 1
    c = i - 1
    while i < len(a) and a[i]=='0':
        i += 1
    if c > i - c:
        ans += 1
    elif c == i - c:
        if a[:c] >= a[c:i]:
            ans += 1
        else:
            ans = 1
    else:
        ans = 1
print(ans)

s = input().strip()
n = len(s)
i = j = k = 0
while i < n:
    j = i
    i += 1
    while i < n and s[i] == '0': i += 1
    if j > i - j: k += 1
    elif j == i - j:
        if s[: j] >= s[j: i]: k += 1
        else: k = 0
    else: k = 0
print(k + 1)

a = input()
i = 0
ans = 1
c = 0
while i < len(a):
    i += 1
    c = i - 1
    while i < len(a) and a[i]=='0':
        i += 1
    if (c > i - c) or (c == i - c and a[:c] >= a[c:i]):
        ans += 1
    else:
        ans = 1
print(ans)

a = input()
i = 0
ans = 1
while i < len(a):
    i += 1
    c = i - 1
    while i < len(a) and a[i]=='0':
        i += 1
    if (c > i - c) or (c == i - c and a[:c] >= a[c:i]):
        ans += 1
    else:
        ans = 1
print(ans)

a = input()
i = 0; ans = 1
while i < len(a):
    i += 1
    c = i-1
    while i < len(a) and a[i] == '0':
        i += 1
    if (c > i-c) or (c == i-c and a[:c] >= a[c:i]):
        ans += 1
    else:
        ans = 1
print(ans)


3

def main():
    s = input()
    n = len(s)
    if n == 1:
        return 1
    
    fst = 1
    if int(s[0]) < int(s[1]):
        fst = 2

    ans = 1
    j = 1
    while j < n and s[j] == '0':
        j += 1
    if j == n:
        return 1
    cur = 1
    for i in range(j + 1, n + 1):
        if i == n or s[i] != '0':
            if (i - cur < cur) or (i - cur == cur and int(s[0]) < int(s[i - cur])):
                ans = 1
            else:
                ans += 1
            cur = 1
        else:
            cur += 1
    return ans
    
        

print(main())


a = input()

i = 0

ans = 1

while i < len(a):

    i += 1

    c = i - 1

    while i < len(a) and a[i]=='0':

        i += 1

    if (c > i - c) or (c == i - c and a[:c] >= a[c:i]):

        ans += 1

    else:

        ans = 1

print(ans)



# Made By Mostafa_Khaled


p = input().strip()

n = len(p)
j = n - 1
ans = 0

while(j >= 0):
    k = j
    while p[k] == '0':
        k -= 1
    
    ln = j - k + 1

    if ln > k:
        ans += 1
        j = -1

    elif ln == k:
        if (p[0] >= p[k]):
            j = k - 1
        else:
            j = -1
        ans += 1

    else:
        ans += 1
        j = k - 1

print(ans)


import sys
from math import *
from collections import *
readints=lambda:list(map(int, input().strip('\n').split()))

s = input()
n = len(s)

arr = deque()

i=n-1
while i>=0:
    j=i
    while j>=0 and s[j]=='0': j-=1
    arr.appendleft(((j,i), 1))
    i=j-1

#print(arr)

def gte(x,y):
    
    if x[1]-x[0]>y[1]-y[0]: return True
    if x[1]-x[0]<y[1]-y[0]: return False
    n = x[1]-x[0]+1
    for i in range(n):
        if s[i+x[0]]>s[i+y[0]]: return True
        if s[i+x[0]]<s[i+y[0]]: return False
        
    return True

while len(arr) > 1:

    x = arr.popleft()
    y = arr.popleft()
    if gte(x[0],y[0]):
        arr.appendleft(((x[0][0],y[0][1]),x[1]+y[1]))
    else:
        arr.appendleft(((x[0][0],y[0][1]),1))
    #print(arr)

print(arr[0][1])
        


def compare(a,b):
    fl = True

    if len(a) > len(b):
        return True
    elif len(a) < len(b):
        return False
    elif len(a) == len(b):
        fl = None
        for i in range(len(a)):
            if int(b[i]) > int(a[i]) and fl == None:
                fl = False
                break
            elif int(a[i]) > int(b[i]) and fl == None:
                fl = True
                break
            
        if fl == None:
            fl = True
            
        return fl

n = input()

l = []
a = ""
i = 0

while i < len(n):
    a += n[i]

    fl = False
    
    while i < len(n) and n[i] == '0':
        l[-1] += '0'
        i += 1
        fl = True

    if fl:
        a = ""
        continue

    l.append(a)

    i += 1
    a = ""

s = 1
for i in (list(range(1,len(l)))):
    if compare(l[i-1],l[i]):
        s = s + 1
    else:
        s = 1
        
    l[i] = l[i-1] + l[i]
    l[i-1] = ''

print(s)


s = input()

r = len(s)
c = 1
for i in range(len(s)-1, 0, -1):
    if s[i] != '0':
        if i > r-i:
            c += 1
            r = i
        elif i == r-i:
            if s[:i] >= s[i:r]:
                c += 1
                r = i
        else:
            break

print(c)


s = input()+'#'
if len(s)==2:
    print(1)
    return
elif '0' not in s:
    if int(s[0])<int(s[1]):
        print(len(s)-2)
    else:
        print(len(s)-1)
else:
    c=0;ind=-1;ans=0
    zer = s.count('0')
    for i in range(len(s)):
        if s[i]=='0':
            c+=1
        else:
            if i-c-1<c+1:
                ans=i
            elif c+1==i-c-1 and s[:i-c-1]<s[i-c-1:i]:
                ans=i
            c=0           
    a=s[:ans].count('0')
    zer-=a 
    print(len(s)-ans-zer)            

 

                   



def cmp(x, y):
    for i in range(min(len(x), len(y))):
        if x[i] < y[i]:
            return True
    return len(x) < len(y)

s = input()
r, c = len(s), 1
for i in range(len(s)-1, 0, -1):
    if s[i] != '0':
        if i > r-i:
            c += 1
            r = i
        elif i == r-i:
            if not cmp(s[:i], s[i:r]):
                c += 1
                r = i
        else:
            break
print(c)