a,b,c=map(int,input().split())
d=0
while (b/a)*100<c:
 b+=1
 d+=1
print(d)

import math
n,x,y=map(float, raw_input().split())
print max(int(math.ceil(n * y / 100) - x), 0)

from math import ceil
n, x, y = [int(x) for x in raw_input().split()]

print max(int(ceil((y*n-100*x)/100.0)), 0)

#!/usr/bin/python

def main():
	result = 0
	n, x, y = map(int, raw_input().split())
	while (x/float(n)) < y/100.0:
		result, x=result+1, x+1
	print result

if __name__=='__main__':
	main()

x, y, z = map(float, raw_input().split())
percentagething = z * 0.01
populationthatcomes = x * percentagething
counter = 0
if y >= populationthatcomes:
    print 0
    exit()
else:
    while y < populationthatcomes:
        y += 1
        counter += 1
        if y >= populationthatcomes:
            print counter
            exit()

import sys

(n, x, y) = [int(x) for x in sys.stdin.readline().strip().split()]

print(max((n*y-1)//100+1-x, 0))

#coding:utf-8
#! usr/bin/env python
import math

nxy=raw_input()
n=int(nxy.split(' ')[0])
x=int(nxy.split(' ')[1])
y=int(nxy.split(' ')[2])

if 1.0*(x)/n>y*1.0/100:
    print(0)
else:
    print int(math.ceil(1.0*(y*n-100*x)/(100)))

# your code goes here
# your code goes here
x,y,z = map(int,raw_input().split())
clones = 0
reqd = 1.0 * x * z / 100
#print reqd - y
if y < reqd:
	clones = reqd - y
	clones = int(clones)
	if clones < reqd - y:
		clones = clones + 1
print int(clones)

n, x, y = map(int, raw_input().split())
print max(0, (n * y + 99) / 100 - x)

n,x,y=map(int,raw_input().split())
if (n*y)%100!=0:
    ans=(n*y)/100+1
else:
    ans=(n*y)/100
if x>=ans:
    print 0
else:
    print ans-x

from math import ceil

n, x, y = map(int, input().split())

tot = ceil(n * y / 100)
print(max(0, tot - x))

import math
n,x,y=map(int,input().split())
y=math.ceil((y/100)*n)
if y<x:
    print(0)
else:
    print(y-x)

import io
import os
#input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline

import math

def main():
    n, x, y = map(int, input().split())
    c = 0
    while math.floor((x+c)/n*100) < y:
        c += 1
    print(c)

if __name__ == '__main__':
    main()

num,wiz,per = map(int,input().split())
k = 0
while (k+wiz)/num*100 < per:
    k += 1
print(k)

import math

(n, x, y) = map(int, input().split(' '))

f = math.ceil((float(y)/100 * n) - x)

print(max(0, f))

from math import ceil

n, x, y = map(lambda x: int(x), raw_input().split())

z = int(ceil(n*y*0.01))

print z-x if z-x>0 else 0

import math
n, x, y = map(int, input().split())

# n * y / 100 = x + c

c = math.ceil(n * y / 100) - x
if c < 0:
	c = 0
print (c)

n,x,y=list(map(int,input().split()))
sam=(y/100)*n
if int(sam)==sam:
    if x>=sam:
        print(0)
    else:
        print(int(sam)-x)
else:
    sam=int(sam)+1
    if x>=sam:
        print(0)
    else:
        print(sam-x)

import math
#for _ in range(int(input())):
n,x,y=map(int,input().split())
d=math.ceil(n*(y/100))
if(d>x):
    print(d-x)
else:
    print(0)

import math
from bisect import bisect_left,bisect,bisect_right
from itertools import accumulate

def index(a, x):
    'Locate the leftmost value exactly equal to x'
    i = bisect_left(a, x)
    if i != len(a) and a[i] == x:
        return i
    raise ValueError

def find_lt(a, x):
    'Find rightmost value less than x'
    i = bisect_left(a, x)
    if i:
        return a[i-1]
    raise ValueError

def find_le(a, x):
    'Find rightmost value less than or equal to x'
    i = bisect_right(a, x)
    if i:
        return a[i-1]
    raise ValueError

def find_gt(a, x):
    'Find leftmost value greater than x'
    i = bisect_right(a, x)
    if i != len(a):
        return a[i]
    raise ValueError

def find_ge(a, x):
    'Find leftmost item greater than or equal to x'
    i = bisect_left(a, x)
    if i != len(a):
        return a[i]
    raise ValueError

st=''

def func(n,x,y):
    return max(0,math.ceil(y*n/100)-x)

for _ in range(1):#int(input())):
    n,a,b=map(int,input().split())
    #n = int(input())
    #inp=input().split()
    #s=input()
    #l1=[]
    #l1=list(map(int,input().split()))
    #l1=list(accumulate(list(map(int,input().split()))))
    #q=int(input())
    #l2 = list(map(int, input().split()))
    #l1=input().split()
    #l2=input().split()
    #func(n,m)
    st+=str(int(func(n,a,b)))+'\n'
print(st)

import sys
my_file = sys.stdin
#my_file = open("input.txt", "r")
line = [int(i) for i in my_file.readline().split()]
n, x, y = line[0], line[1], line[2]
res = 0
while x < n*y/100:
    x += 1
    res += 1
print(res)

n, x, y = (int(x) for x in input().split())
print(max(0, -((100 * x - n * y) // 100)))

import math
n, x, y = map(float, raw_input().split())
y /= 100.0
ans = n * y - x
if ans > 0.0:
    print int(math.ceil(ans))
else:
    print 0

import math
n_x_y = list(map(int,input().split()))
minn = math.ceil((n_x_y[2] / 100) * n_x_y[0])
req = minn - n_x_y[1]
if req < 0 :
    print('0')
else:
    print(req)

from math import ceil

X = list(map(int, input().split()))
Result = (ceil((X[0] * X[2]) / 100)) - X[1]
print(Result if Result > 0 else 0)

import math
string = input()
n, x, y = map(int, string.split())
a = math.ceil(y / 100 * n)
if a < x:
    print(0)
else:
    print(a - x)

import math
n,x,y=map(int,input().split())
per=(y/100)*n
t=math.ceil(per)
t-=x
if t<0:
    print("0")
else:
    print(t)

n, x, y = map(int, raw_input().split())
print max((n * y + 99) / 100 - x, 0)

import math
a,b,c=map(int,input().split())
p=math.ceil((c*a)/100)
if p<=b:print(0)
else:print(p-b)

import sys
import math

n, x, y = [int(x) for x in (sys.stdin.readline()).split()]

req = int(math.ceil(y / 100.0 * n))

if(req - x < 0):
    print(0)
else:
    print(req - x)

import math
a,b,c=map(int,input().split())
print(math.ceil(-min(0,-a*c/100+b)))

import sys

def readints() :
    l = sys.stdin.readline()
    return map(int, l.split(' '))

def readstring() :
    l = sys.stdin.readline()[:-1]
    return l

def readint() :
    l = sys.stdin.readline()
    return int(l)

def clearchars(s, chars) :
    for c in chars :
        s = s.replace(c, '')
    return s

def gcd(a, b) :
    if (a < b ) :
        a, b = b, a
    if b == 0 :
        return a
    return gcd(b, a % b)

n, x, y = readints()

print max([0, n * y / 100 - x + ( (n * y) % 100 != 0 )])

inp = map(float, raw_input().split())
res = inp[0]*(inp[2]/100) - inp[1]
a = 1 if res - int(res) > 0 else 0
print 0 if res < 0 else int(res + a)

n,m,k=[int(x) for x in input().split(' ')]
per=(n*k+99)//100
print(max(0,per-m))

import math
n, x, y = map(int, input().split())

p = y * n / 100
t = math.ceil(p - x)
print(t if t >= 0 else 0)

import math
n, x, y = map(int, input().split())
ans = max(0, math.ceil(y / 100 * n) - x)
print(ans)

import math
n,x,y=map(int,input().split())
xx=max(0,math.ceil(n*y/100)-x)
print(xx)

n, x, y = map(int,input().split())
import math
print (0 if x>=n*y/100 else math.ceil(n*y/100 - x))

n, x, y = map(int,input().split())
import math
if x >= n*y/100:
    print(0)
else:
    print(math.ceil(n*y/100 - x))

n,x,y=[int(i) for i in input().split()]
clone=0
z=False
if not x/n*100<y:
	print(0)
	z=True
while x/n*100<y:
	x+=1
	clone+=1
if not z: print(clone)

from __future__ import division
import math
n,x,y = map(int,raw_input().split())
print max(0,int(math.ceil(n*y/100-x)))

n, x, y = map(float, raw_input().split())
k = 0
while float(y/100) > float(x/n):
    k += 1
    x += 1
print k

from math import ceil
n,x,y = map(int,input().split())
total_people_need = ceil((float(n)/100) * float(y))
puppet_need = max(int(total_people_need) - x, 0)
print(puppet_need)

import math

(n, x, y) = [int(r) for r in input().split()]
print(math.ceil(max(0, n * y / 100 - x)))

n,x,y=map(int,input().split())
if (n*y)/100>(n*y)//100:
    reqad=((n*y)//100)+1
else:
    reqad=((n*y)//100)
ans=reqad-x
if ans<0:
    print(0)
else:
    print(ans)

n,x,y= map(int,raw_input().split())

print max(0,n*y/100+1-x if n*y%100 else n*y/100-x)

n, x, y = map(int, input().split())

people = n * y / 100
if not people.is_integer():
    people = int(people) + 1
else:
    people = int(people)

if people < x:
    print(0)
else:
    print(people - x)

import math
i=lambda :map(int,raw_input().split(" "))
a,b,c=i()
l=(float(a)*c/100)
#print l
if l-int(l)>0.0:
	l=int(l)+1
#print l

#print l
if l<=b:
	print "0"
else:
	print int(l-b)

import math
n,x,y=map(int,input().strip().split()[:3])
if x>=(math.ceil(y*n)/100):
	print(0)
else:
	k=math.ceil((y*n)/100)
	p=k-x
	print(p)

import math
n,x,y=map(int,input().split())
ans=math.ceil((y*n/100))
if x>=ans:
    print(0)
else:
    print(ans-x)

a,b,c=map(int,input().split())
r=0
while (b/a)*100<c:
 b+=1
 r+=1
print(r)

from sys import stdin, stdout

n, x, y = map(int, stdin.readline().split())

if (x / n) * 100 >= y:
    stdout.write('0')
else:
    l = 0
    r = n * y

    while r - l > 1:
        m = (r + l) // 2

        if (x + m) / n * 100 >= y:
            r = m
        else:
            l = m

    stdout.write(str(r))

n,x,y=map(int,raw_input().split())
import math
result=int(math.ceil(n*y/100.0-x))
if result<0:
    result=0
print result

a,b,c=map(int,input().split())
d=0
while (b/a)*100<c:
 b+=1
 d+=1
print(d)

import math

a=input()
p=a.split()
n=float(p[0])
x=float(p[1])
y=float(p[2])

out=math.ceil((y/100)*n)

if (int(out-x)>0):
    print (int(out-x))
else:
    print (0)

n, x, y = map(int, input().split())

w = x

y /= 100
ans = 0

while w/n < y:
    w += 1
    ans += 1
print(ans)

from math import ceil
n, x, y = list(map(int, input().split()))
final = (ceil((n * y) / 100)) - x
if final < 0:
    print(0)
else:
    print(final)

# CodeForcesian
# ♥
# اگه ایمان داری که روزای خوب تو راهن
# روزای خوب قطعا به سمتت میاد

import math
n, x, y = [int(s) for s in input().split(' ')]

c = max(math.ceil(n * (y / 100) - x), 0)
print(c)

import math
n , x , y = map(int,input().split())
a =((n*y)/100)
if round(a)>a:
    a=round(a)
if round(a)<a:
    a=round(a)+1
if x == a:
    print('0')
elif a-x>=0:
    print(int((a-x)))
else:
    print('0')

I=lambda:map(int, raw_input().split())
n,x,y=I()
print max((n*y+99)/100-x,0)

z=input
mod = 10**9 + 7
from collections import *
from queue import *
from sys import *
from collections import *
from math import *
from heapq import *
from itertools import *
from bisect import *
from collections import Counter as cc
from math import factorial as f
def lcd(xnum1,xnum2):
    return (xnum1*xnum2//gcd(xnum1,xnum2))

################################################################################

"""

n=int(z())

for _ in range(int(z())):

x=int(z())

l=list(map(int,z().split()))

n=int(z())

l=sorted(list(map(int,z().split())))[::-1]

a,b=map(int,z().split())

l=set(map(int,z().split()))

led=(6,2,5,5,4,5,6,3,7,6)

vowel={'a':0,'e':0,'i':0,'o':0,'u':0}

color-4=["G", "GB", "YGB", "YGBI", "OYGBI" ,"OYGBIV",'ROYGBIV' ]

"""

###########################---START-CODING---###############################################
for _ in range(1):
    n,x,y=map(int,input().split())
    w=x
    m=n-x
    t=ceil(n*y/100)
    print(max(0,t-x))

import math
n, x, y = map(int, raw_input().split())
u = math.floor((n * (float(y) / 100) + 0.9999))
print(max(0, int(u) - x))

import math
n, x, y = map(int, raw_input().split())
result = int(math.ceil(y * n * 1.0 / 100)) - x
print result if result > 0 else 0

a, b, c = map(int, input().split())
c/=100
a*=c
a*=10
finals = 0
if a%10 > 0:
    a/=10
    finals = int(a)+1
else:
    a/=10
    finals = int(a)
if finals <= b:
    finals = 0
    print(finals)
else:
    print(finals-b)

import math
n,x,y = [int(x) for x in raw_input().split()]

req = math.ceil((n*y)/100.0)
print (0,int(req-x))[(req-x)>0]

from math import ceil

n,x,y = map(int, input().split())

print(max(0,ceil(n*y/100) - x))

import math
n,x,y=list(map(int,input().split()))

a=math.ceil(n*y/100)

if a>x:
    print(a-x)
else:
    print(0)

import math

n, x, y = map(int, raw_input().split(" "))
print max(int(math.ceil((y / 100.0) * n - x)), 0)

import math
n,x,y=map(int,input().split())
req=math.ceil(y/100*n)

print(max(0,req-x))

(n, x, y) = map(int, raw_input().strip().split())

p = n*(y*0.01)
if round(p) == p:
    m = int(p)-x
else:
    m = int(p)+1-x

if m >=0:
    print m
else:
    print 0

import math
n, x, y = map(float, raw_input().split())
q = int( math.ceil(y * n / 100.0) - x )
print q if q >= 0 else 0

n,x,y = [int(i) for i in raw_input().split()]
c = 0
while float(x+c)/n*100 < y:
    c += 1
print c

#!/usr/bin/env python
#-*- coding:utf-8 -*-

from math import ceil
import sys
readin=sys.stdin.readline
n,x,y=map(int,readin().split());
val= int(ceil((y*n/100.0)))-x
if(val>0):
	print val
else:
	print 0

from sys import stdin

n, x, y = map(int, stdin.readline().split())
print max(0, (n * y + 99) / 100 - x)

people,wizards,Percent= map(int,(raw_input()).split())
RequirementPeople=Percent*people/100.0
if (RequirementPeople%1!=0):RequirementPeople+=1

print max(int(RequirementPeople-wizards),0)

n,x,y=map(int,input().split())
if((y*n)%100!=0):
    print(int(y*n/100)-x+1)
else:
    print(int(y*n/100)-x)

from math import ceil
n,x,y=map(int,input().split())
ans=max(0,ceil(y*n//100)-x)
print(int(ans))

n, x, y = map(int, raw_input().split())
a = float(n)*float(y)/100.0
c = str(a).split('.')
a = int(a)
if(int(c[1]) != 0):
	a = a+1
print a-x

n, x, y = map(int, input().split())

people = n * y / 100
if not people.is_integer():
    people = int(people) + 1
else:
    people = int(people)

print(people - x)

a,b,c=map(int,input().split())
g=(c-b/a*100)/(100/a)
if int(g)!=g:g=int(g)+1
print(int(g))if g>0 else print(0)

#!/usr/bin/python

from collections import deque
from collections import Counter

def ir():
    return int(raw_input())

def ia():
    line = raw_input()
    line = line.split()
    return map(int, line)

n, x, y = ia()

for p in range(100000):
    if (x + p) * 100  >= y * n: print p; break

import math
n, x, y = map(int, input().split())

p = y * n / 100
print(math.ceil(p - x))

#!/usr/bin/env python
#-*- coding:utf-8 -*-

from math import ceil
import sys
readin=sys.stdin.readline
n,x,y=map(int,readin().split());
print int(ceil((y*n/100.0)))-x

a, b, c = map(int, input().split())
print(a,b,c)

n,w,c = map(int,input().split())
k = (c*n)/100
if int(k)!=k:
    k = int(k)+1
print(int(k)-w)

import math
n, x, y = map(int, input().split())

porc = (y*n)/100
# print(porc)
faltam = math.ceil(porc - x)
print(faltam)

import math as m
n=[float(i) for i in input().split()]
print(m.ceil(n[0]*(n[2]/100))-int(n[1]))

n, x, y = input().split()
n, x, y = int(n), int(x), int(y)
percent = ((y * n) / 100)
if int(percent) != percent:
    percent += 1
    percent = int(percent)
print(int(percent - x))

import sys

hulp=[int(x) for x in sys.stdin.readline().split()]

n,x,y=hulp[0],hulp[1],hulp[2]

grens=int(n*1.0/100*y+0.9)

aantal=max(0,grens-x)

print aantal

n,x,y=list(map(int,input().split()))
sam=(y/100)*n
if int(sam)==sam:
    if x>=sam:
        print(0)
    else:
        print(sam-x)
else:
    sam=int(sam)+1
    if x>=sam:
        print(0)
    else:
        print(sam-x)

n = input().split()
x = int(n[1])
y = int(n[2])
n = int(n[0])
t = n -y
res = n * y / 100
if not res == round(res):
    res = round(res)+1

res = int(-x +res)
res = max(res,0)
print(res)

import sys
import math
line = [int(x) for x in sys.stdin.readline().split()]

target = line[0]*0.01*line[2]
soln = math.ceil(target - line[1])

if soln > 0:
    print int(soln)
else:
    print 0

import math

n, k, p = map(int, input().split())

need = math.ceil(n*p/100)

print(need-k)

n,x,y=[int(x) for x in input().strip().split()]
def ceil(val):
	if int(val)+1>val:
		return int(val)+1
	else:
 		return int(val)
num = ceil(n*y/100)
count = max(0,num-x)
print(count)

from math import ceil
n,x,y = list(map(int,raw_input().split()))
y = ceil(n / 100.0 * y)
if x >= y:
	print 0
else:
	print y - x

n, x, y = map(int, raw_input().split())
print n*y/100-x

s=input().split()
for i in range(3):
    s[i]=int(s[i])
v=s[0]/100
m=round(v*s[2]-s[1])
if m!=0:
    print(m)
else:
    print(m+1)

[n, x, y] = map(int, raw_input().split())

rem = 0
if (y*n)%100 != 0:
	rem = 1
rem = y*n/100 - x + rem

if rem<0:
	rem = 0

n,w,p=map(int,input().split())
x=(n*p)/100
if x%1==0:
	print(int(x-w))
else:
	print(int(x)+1-w)

from math import ceil

n, x, y = map(int, input().split())
total = n*(y/100)
total = ceil(total)
print(total - x)

a=list(input().split())
n=int(a[0])
x=int(a[1])
y=int(a[2])
per=(x*100)/n
print(per)
y=y-per
print(y)
if y<=0:
    print(0)
else:
    if (y*n/100) - int(y*n/100)==0:
        print(int (y*n/100))
    else:
        print(int((y*n)/100) +1)

import math
n , x , y = map(int,input().split())
a =((n*y)/100)
if round(a)>a:
    a=round(a)
if round(a)<a:
    a=round(a)+1
if x == a:
    print('0')
else:
    print(int(abs(a-x)))

a, b, c=map(float, raw_input().split())
t=float((a/100)*c)
if t%1!=0:
  t=int(t+1)
print int(abs(b-t))

from math import ceil
a=list(int(i) for i in raw_input().split(' ',3))
print "%d" %(ceil((a[2]/100.0)*a[0]-a[1]))

import math

data = input().split()

N, X, Y = int(data[0]), int(data[1]), int(data[2])

print(math.ceil(N * (Y/100)) - X)

import math
I=lambda:map(int, raw_input().split())
n,x,y=I()
print -min(0, int(math.ceil(-n*y/100.0))+x)

n , x , y = map(int,input('').split(" "))

s = (y * n)
if s % 100 !=0:
    s = int(s / 100)
    s = s+1
    ans = s - x
else :
    s = int(s / 100)
    ans = s - x

print(ans)

n, x, y = map(int, raw_input().split())

required = n * y // 100 + ((n * y) % 100 != 0)

print required - x

import string
import math

def ii():
    ii = []
    for s in string.split(raw_input()):
        ii.append(int(s))
    return ii

ii = ii()
#print ii
a = int(round(ii[0] * ii[2] / 100 + 0.9999999999999))
#print a
b = ii[1]
if (a <= b):
    print 0
else:
    print a - b

#!/usr/bin/python

from collections import deque
from collections import Counter

def ir():
    return int(raw_input())

def ia():
    line = raw_input()
    line = line.split()
    return map(int, line)

n, x, y = ia()

lo, hi = 0, 100000000

for i in range(100):
    mi = (lo + hi) // 2
    if (x + mi) * 100  > y * n: hi = mi
    else                      : lo = mi

print mi

from math import ceil

n, x, y = map(lambda x: int(x), raw_input().split())

z = ceil(n*y*0.01)

print z-x if z-x>0 else 0

import math
n,m,k=[float(z) for z in raw_input().split(' ')]
sub=0
ans= n*k/100

mad=math.ceil(ans)

print int(mad-m)

x, y, z = map(float, raw_input().split())
percentagething = z * 0.01
populationthatcomes = x * percentagething
counter = 0
if y >= populationthatcomes:
    print 0
    exit()
else:
    for x in xrange(10000):
        y += 1
        counter += 1
        if y >= populationthatcomes:
            print counter
            exit()

from math import ceil

n, x, y = map(int, input().split())

tot = ceil(n * y / 100)
print(tot - x)

from math import ceil
n,x,y = map(int,input().split())
p = ceil((n*y)/100)
if p<x:
    print(p)
else:
    print(p-x)

a, b, c = map(int, input().split())
c/=100
a*=c
finals = round(a)
print(finals)

n,w,c = map(int,input().split())
k = (c*n)/100
if int(k)!=k:
    k = int(k)+1
print(int(k)-w)

a, b, c = map(int, input().split())
print(a,b,c)

import math
a, b, c = map(int, input().split(' '))
print(min(math.ceil(a*c/100 - b), 0))

#168A
import math
n, x, y = map(int, input().split())
print(math.ceil((n*y)/100) - x)

import math
n,w,p = map(int,input().split())

needed = int(math.ceil((n*p)/100))
print(needed-w)

import math as m
n=[float(i) for i in input().split()]
print(m.ceil(n[0]*(n[2]/100))-int(n[1]))

import math
n,x,y = [int(x) for x in raw_input().split()]

req = math.ceil((n*y)/100)
print req-x

import string
import math

def ii():
    ii = []
    for s in string.split(raw_input()):
        ii.append(int(s))
    return ii

ii = ii()
#print ii
a = int(round(ii[0] * ii[2] / 100))
#print a
b = ii[1]
if (a <= b):
    print 0
else:
    print a - b

a, b, c = map(int, input().split())
c/=10
a*=c
if a%10 > 0:
    a/=10
    round(a)+1
else:
    a/=10
    round(a)

print(a-b)

import sys

def input():    return sys.stdin.readline().strip()
def iinput():   return int(input())
def rinput():   return map(int, sys.stdin.readline().strip().split())
def get_list(): return list(map(int, sys.stdin.readline().strip().split()))

n,x,y=rinput()

a=y*n/100

if(int(a)==a):
    s=a
else:
    s=a+1

print(int(s-x))

print [(n*y-1)/100+1-x for n,x,y in [[int(c) for c in raw_input().split()]]][0]

import math
I=lambda:map(int, raw_input().split())
n,x,y=I()
print -min(0, int(math.ceil(-n*y/100.0))+x)

import math

a=input()
p=a.split()
n=float(p[0])
x=float(p[1])
y=float(p[2])

out=math.ceil((y/100)*n)

print (int(out-x))

n , x   , y =map(int,input().strip().split())

requi   =      ((x)/n)*100

if requi < y:
	for c in range(0, 10**4):
		requi = ((x+ c)/n)*100
		if requi>=y:
			print(c)
			break
else:
	print(0)

from math import ceil

n, x, y = map(lambda x: int(x), raw_input().split())

z = ceil(n*y*0.01)

print z-x if z-x>0 else 0

import math
n,x,y = map(int,raw_input().split())
count = int(math.ceil(y*n*1.0/100))-x
print count

import math

data = input().split()

#data = open('inputs.txt', 'r').read().split()
n = int(data[0])
x = int(data[1])
y = int(data[2])

#print("%d | %d | %d"% (n, x, y))

demo = math.ceil((y*n)/100)
res = abs(x-demo)
print(res)

a, b, c = map(int, input().split())
c/=100
a*=c
a*=10
finals = 0
if a%10 > 0:
    a/=10
    finals = round(a)+1
else:
    a/=10
    finals = round(a)
if finals <= b:
    finals = 0
    print(finals)
else:
    print(finals-b)

n,x,y=map(int,input().split())
ans=y*n/100-x
if ans<1 and ans>0:
    ans=1
print(int(ans))

a,b,c=map(int,input().split())
g=(c-b/a*100)/(100/a)
if round(g)!=g:g=round(g)+1
print(int(g)) if g>0 else print(0)

import math
n, x, y = map(int, input().split())

porc = (y*n)/100
# print(porc)
faltam = math.ceil(porc - x)
print(faltam)

import math
a, b, c = map(int, input().split(' '))
print(min(math.ceil(a*c/100 - b), 0))

[n, x, y] = map(int, raw_input().split())

rem = 0
if (y*n)%100 != 0:
	rem = 1
rem = y*n/100 - x + rem

if rem<0:
	rem = 0

def main():
	n,x,y=[int(ele) for ele in raw_input().split()]
	yp=int(float(n*y)/100)
	if((n*y)%100!=0):
		yp+=1;
	print yp-x

if __name__=="__main__":
	main()

from math import ceil
a=list(int(i) for i in raw_input().split(' ',3))
print "%d" %(ceil((a[2]/100.0)*a[0]-a[1]))

n,x,y= map(int,raw_input().split())
if n*y%100:
    print n*y/100+1-x
else:
    print n*y/100-x

import sys

def readints() :
    l = sys.stdin.readline()
    return map(int, l.split(' '))

def readstring() :
    l = sys.stdin.readline()[:-1]
    return l

def readint() :
    l = sys.stdin.readline()
    return int(l)

def clearchars(s, chars) :
    for c in chars :
        s = s.replace(c, '')
    return s

def gcd(a, b) :
    if (a < b ) :
        a, b = b, a
    if b == 0 :
        return a
    return gcd(b, a % b)

n, x, y = readints()

print n * y / 100 - x + ( (n * y) % 100 != 0 )

import math

n,x,y = [int(x) for x in raw_input().split()]

print int(math.ceil(float(y * n)/100.0) - float(x))

[n, x, y] = map(int, raw_input().split())

rem = 0
if (y*n)%100 != 0:
	rem = 1
print y*n/100 - x + rem

import math
n,x,y=map(int,input().split())
city=n-x
per=(y/100)*n
t=math.ceil(per)
print(t-x)

import math as m
n,x,y=map(int,input().split())
ans=m.ceil((n*y)/100)-x
print(ans)

#coding:utf-8
#! usr/bin/env python
import math

nxy=raw_input()
n=int(nxy.split(' ')[0])
x=int(nxy.split(' ')[1])
y=int(nxy.split(' ')[2])

if 1.0*(x)/n>100*y:
    print 0
elif y>=100:
    print int(math.ceil(1.0*(y*n-100*x)/(100-y)+1))
else:
    print int(math.ceil(1.0*(y*n-100*x)/(y-100)+1))

inp = map(float, raw_input().split())
print inp[0]*(inp[2]/100) - inp[1]

n, x, y = (int(x) for x in input().split())
print(-((100 * x - n * y) // 100))

from math import *
n,x,y=map(int,input().split())
xx=(x*100)/n
print(xx)
yy=y-xx
z=(yy*n)/100
print(ceil(z))

n, x, y = map(int, input().split())
need = round(n * y / 100) + (round(n*y/100) != n*y/100)
print(max(need - x, 0))

import math
n, x, y = map(int, raw_input().split())
u = math.floor((n * (float(y) / 100) + 0.9))
print(int(u) - x)

from math import ceil
n,x,y=map(int,input().split())
rew=y*n/100
print(ceil(rew)-x)

import math
n,x,y=map(int,input().split())
k=(y/100)*n
k=math.ceil(k)
print(abs(k-x))

import math
def  main():
	n,x,y = map(int,input().split())
	y = y/100
	people = n*y
	# print(math.ceil(people))
	print(int(math.ceil(people)-x))

main()

import math
n,m,k=[float(z) for z in raw_input().split(' ')]
sub=0
ans= n*k/100

mad=math.ceil(ans)

print int(mad-m)

import sys

hulp=[int(x) for x in sys.stdin.readline().split()]

n,x,y=hulp[0],hulp[1],hulp[2]

grens=int(n*1.0/100*y+0.9)

aantal=grens-x

print aantal

#coding:utf-8
#! usr/bin/env python
nxy=raw_input()
n=int(nxy.split(' ')[0])
x=int(nxy.split(' ')[1])
y=int(nxy.split(' ')[2])

if 1.0*(x)/n>y:
    print 0
elif y>=100:
    print int((y*n-100*x)/(100-y)+1)
else:
    print int((y*n-100*x)/(y-100)+1)


n=int(input())
f=0
while (n>0):
    f+=1
    n-=max(set(map(int,str(n))))
print f

def gd(x):
	return max(map(int, list(str(x))))

def next(mmax, x):
	for i in range(x+1,x+10):
		if i-max(mmax, gd(i)) >= x:
			return i

memo = {}

def f(mmax, nn, pad):

	key = (mmax, nn, pad)
	if key in memo:
		return memo[key]

	orpad = pad

	if nn == 1:
		start = pad
		last = start
		end = 9
		tot = 1
		for i in range(start+1, end+1):
			if i-max(mmax, gd(i)) >= last:
				last = i
				tot += 1

		ans = (tot, last%10)

	else:
		tot = 0
		lr = 9
		for d in range(lr+1):
			t, lastbeg = f(max(mmax, d), nn-1, pad)
			lastbeg += d*(10**(nn-1))
			tot += t
			pad = ( next(mmax, lastbeg) ) % 10

		ans = (tot, lastbeg)

	memo[key] = ans
	#~ print "f(%d, %d, %d) = (%d, %d)" % (mmax, nn, orpad, ans[0], ans[1])
	return ans

N = input()
nn = len(str(N))
dig = [0] + map(int,list(str(N)[::-1]))

def g(mmax, nn, pad):
	#~ print "**", mmax, nn, pad
	tot = 0
	if nn == 1:
		start = pad
		last = start-10
		end = dig[nn]
		tot = 0
		for i in range(start, end+1):
			if i-max(mmax, gd(i)) >= last:
				last = i
				tot += 1
		return tot

	else:
		for d in range(dig[nn]):
			t, lastbeg = f(max(mmax, d), nn-1, pad)
			lastbeg += d*(10**(nn-1))
			tot += t
			pad = ( next(mmax, lastbeg) ) % 10
		return tot + g(max(mmax, dig[nn]), nn-1, pad)

f(0, nn, 0)
print g(0, nn, 0)-1

import functools

Maxn=10000005

@functools.lru_cache(10000)
def dp(x, y):
	now = (x,y)

	if (x<10):
		# return (x || y, x-max(x,y))
                # print(f'x={x} y={y}')
                first = 1 if x or y else 0
                return (first, x-max(x,y))

	mod=1
	while(mod<=x//10):
		mod*=10

	maxDig=x//mod

	part1=dp(x%mod, max(maxDig,y))
	part2=dp(x-x%mod+part1[1], y)
	return (part1[0]+part2[0], part2[1])

def solve():
	n = int(input())
	Ans=dp(n,0)[0]
	print(Ans)

solve()

'''input
24
'''

n = int(raw_input())

ans = 0
while n>0:
    m = 0
    temp = n
    while temp>0:
        m = max(m, temp%10)
        temp/=10
    n-=m
    ans += 1
print ans

# Target Specialist

"""
Beautiful is better than ugly.
    Explicit is better than implicit.
Simple is better than complex.
    Complex is better than complicated.
Flat is better than nested.
    Sparse is better than dense.

    * Readability counts *

 // Author : raj1307 - Raj Singh
 // Date   : 14.07.19

"""

from __future__ import division, print_function
import os,sys
from io import BytesIO, IOBase

if sys.version_info[0] < 3:
    from __builtin__ import xrange as range
    from future_builtins import ascii, filter, hex, map, oct, zip
else:
    _str = str
    str = lambda x=b"": x if type(x) is bytes else _str(x).encode()

def ii(): return int(input())
def si(): return input()
def mi(): return map(int,input().strip().split(" "))
def li(): return list(mi())

def dmain():
    sys.setrecursionlimit(100000000)
    threading.stack_size(40960000)
    thread = threading.Thread(target=main)
    thread.start()

#from collections import deque, Counter, OrderedDict,defaultdict
#from heapq import nsmallest, nlargest, heapify,heappop ,heappush, heapreplace
#from math import ceil,floor,log,sqrt,factorial,pow,pi
#from bisect import bisect,bisect_left,bisect_right,insort,insort_left,insort_right
#from decimal import *,threading
#from itertools import permutations

abc='abcdefghijklmnopqrstuvwxyz'
abd={'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, 'f': 5, 'g': 6, 'h': 7, 'i': 8, 'j': 9, 'k': 10, 'l': 11, 'm': 12, 'n': 13, 'o': 14, 'p': 15, 'q': 16, 'r': 17, 's': 18, 't': 19, 'u': 20, 'v': 21, 'w': 22, 'x': 23, 'y': 24, 'z': 25}
mod,MOD=1000000007,998244353
vow=['a','e','i','o','u']
dx,dy=[-1,1,0,0],[0,0,1,-1]
def getKey(item): return item[0]
def sort2(l):return sorted(l, key=getKey)
def d2(n,m,num):return [[num for x in range(m)] for y in range(n)]
def isPowerOfTwo (x): return (x and (not(x & (x - 1))) )
def decimalToBinary(n): return bin(n).replace("0b","")
def ntl(n):return [int(i) for i in str(n)]

def powerMod(x,y,p):
    res = 1
    x %= p
    while y > 0:
        if y&1:
            res = (res*x)%p
        y = y>>1
        x = (x*x)%p1
    return res

def gcd(x, y):
    while y:
        x, y = y, x % y
    return x

def isPrime(n) : # Check Prime Number or not
    if (n <= 1) : return False
    if (n <= 3) : return True
    if (n % 2 == 0 or n % 3 == 0) : return False
    i = 5
    while(i * i <= n) :
        if (n % i == 0 or n % (i + 2) == 0) :
            return False
        i = i + 6
    return True

# For getting input from input.txt file
#sys.stdin = open('input.txt', 'r')

# Printing the Output to output.txt file
#sys.stdout = open('output.txt', 'w')

def main():

    n=ii()

    ans=0
    while(n!=0):
        ans+=1
        l=ntl(n)
        m=max(l)
        n-=m
    print(ans)

# region fastio

BUFSIZE = 8192

class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        if self.buffer.tell():
            return self.buffer.read()
        return os.read(self._fd, os.fstat(self._fd).st_size)

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            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()

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

def print(*args, **kwargs):
    """Prints the values to a stream, or to sys.stdout by default."""
    sep, file = kwargs.pop("sep", b" "), kwargs.pop("file", sys.stdout)
    at_start = True
    for x in args:
        if not at_start:
            file.write(sep)
        file.write(str(x))
        at_start = False
    file.write(kwargs.pop("end", b"\n"))
    if kwargs.pop("flush", False):
        file.flush()

sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
input = lambda: sys.stdin.readline().rstrip(b"\r\n")

# endregion

if __name__ == "__main__":
    main()
    #dmain()

import math
import sys
input = sys.stdin.readline
n = int(input())
opt = 0
while n != 0:
  n -= int(max(list(str(n))))
  opt += 1
print(opt)

#	!/bin/env python3
#	coding: UTF-8

#	✪ H4WK3yE乡
#	Mohd. Farhan Tahir
#	Indian Institute Of Information Technology and Management,Gwalior

#	Question Link
#	https://codeforces.com/problemset/problem/331/C1
#

# ///==========Libraries, Constants and Functions=============///

import sys

inf = float("inf")
mod = 1000000007

def get_array(): return list(map(int, sys.stdin.readline().split()))

def get_ints(): return map(int, sys.stdin.readline().split())

def input(): return sys.stdin.readline()

# ///==========MAIN=============///

def recurse(n):
    dp = [inf for _ in range(1000005)]
    for i in range(10):
        dp[i] = 1
    for i in range(10, 1000001):
        x = i
        while x > 0:
            r = x % 10
            x //= 10
            if r > 0:
                dp[i] = min(dp[i], dp[i-r]+1)
    return dp[n]

def main():
    n = int(input())
    if n == 0:
        print(0)
        return
    print(recurse(n))

if __name__ == "__main__":
    main()

s=input()
n=int(s)
ans=0
while n!=0:
    for i in range(9,0,-1):
        if str(i) in str(n):
            n-=i
            ans+=1
            break;
print(ans)

from sys import stdin
input_ = stdin.readline
magic_num  = input_()
operations = 0
i = 0
while(i < int(magic_num)):
    if magic_num == 0:
        break
    max_num = max({int(x) for x in str(magic_num).strip()})
    magic_num = int(magic_num) - max_num
    operations += 1

print(operations)

n = int(input())
s = 0
while n != 0:
    n -= max([int(c) for c in str(n)])
    s += 1
print(s)

k = int(input())

mini = []
mini.append(0)

for i in range(k):
    p = i+1
    if(p < 10):
        mini.append(1)
    else:
        digits = [int(d) for d in str(p)]
        mini.append(1000000)
        for d in range(len(digits)):
            mini[p] = min(mini[p], 1+mini[p-digits[d]])
print(mini[k])

n=int(input())
def ispres(num):
 dig=0
 m=num
 while m>0:
    d=m%10
    dig=max(dig,d)
    m=m//10
 return dig
dp=[999999 for _ in range(n+1)]

dp[n-ispres(n)]=1
if n==0:
    print(0)
    exit(0)
for i in range(n,-1,-1):
        k=ispres(i)

        if i-k>=0:

           dp[i-k]=min(dp[i-k],dp[i]+1)

if dp[0]==999999:
    print(0)
    exit(0)
print(dp[0])

n=int(input())
c=0
while(n>0):
	l=max(str(n))
	n=n-int(l)
	c+=1
print(c)

import math
#q=int(input())
q=1
for _ in range(q):
    n=int(input())
    ans=0
    while(n>0):
        ans+=1
        k=n
        maxx=0
        while(k>0):
            x=k%10
            maxx=max(x,maxx)
            k//=10
        n-=maxx
    print(ans)

import sys
from math import sqrt, floor, factorial, gcd
from collections import deque, Counter
inp = sys.stdin.readline
read = lambda: list(map(int, inp().strip().split()))

def solve():
	n = int(inp()); s = 0
	while n > 0:
		m = n%10; t = n
		while t > 0:
			m = max(m, t%10)
			t //= 10
		n -= m
		# print(n, m)
		s += 1
	print(s)

if __name__ == "__main__":
	solve()

n=int(input())
count=0

while n:
    n -= max(int(i) for i in str(n))
    count += 1

print (count)

n=int(input())
ans=0
while n!=0:
    p=int(max(list(str(n))))
    n-=p
    ans+=1

print(ans)

# -*- coding: utf-8 -*-
"""
Created on Thu Sep 17 01:20:34 2020

@author: Dark Soul
"""
n=int(input(''))
def maxdig(n):
    s=-1
    while n:
        s=max(s,n%10)
        n=n//10
    return s
sol=0
while n:
    sol+=1
    n-=maxdig(n)
print(sol)

# https://codeforces.com/problemset/problem/331/C1

import math

def to_digits(n):
    return [int(d) for d in str(n)]

def to_integer(digits):
    accum = 0
    factor = 1
    for d in reversed(digits):
        accum += factor * d
        factor *= 10

    return accum

def split(digits):
    d = 0
    index = 0
    for i in range(len(digits)):
        if digits[i] >= d:
            d = digits[i]
            index = i

    # print(str(d) + " " + str(digits[index:]))
    return (d, digits[i:])

memoize = {}

def num(x):
    y = 0
    while x > 0:
        digits = to_digits(x)
        d, r = split(digits)
        rint = to_integer(r)
        n = rint // d
        mod = rint % d
        if mod == 0 and n != 0:
            n = n
        elif rint < d or d < rint:
            n = n + 1

        y += n
        x = x - n * d

    return y

x = int(input())
print(num(x))

n = int(input())
ans = 0
while n:
    maxd = 0
    tmp = n
    while tmp:
        maxd = max(maxd, tmp % 10)
        tmp //= 10

    n -= maxd
    ans += 1

print(ans)

n = int(input())
dp = [0] * (n + 1)
for i in range(1, n + 1):
    tmp = i
    dp[i] = 10 ** 18
    while tmp > 0:
        d = tmp % 10
        tmp //= 10
        # tmp = tmp // 10
        dp[i] = min(dp[i], dp[i - d])
    dp[i] += 1
print(dp[n])

n = int(input())
o = 0
while n > 0:
    n -= int(max(str(n)))
    o += 1
print(o)

s = int(input())
cnt = 0
while s:
    s -= max(map(int, str(s)))
    cnt += 1
print(cnt)

def findMax(N):
    Max = 0
    while(N!=0):
        Rem = N%10
        N = N//10
        Max = max(Max,Rem)
    return Max
N =int(input())
count = 0
while(N!=0):
    X = findMax(N)
    N-=X
    count+=1
print(count)

n  = int(input())
s=0

while n!=0:
    u = list(str(n))
    u.sort()
    n-=int(u[-1])
    s+=1

print(s)

dp = [0] * 1000005
for i in range(1, 10):
    dp[i] = 1

for i in range(10, 1000001):
    minx = 10000000
    for j in str(i):
        if j != '0':
            minx = min(minx, dp[i-int(j)]+1)

    dp[i] = minx

print(dp[int(input())])

n=int(input())
count=0
while (n>0):
    s1=str(n)
    l1=[]
    for i in range (len(s1)):
        l1.append(int(s1[i]))
    n-=max(l1)
    count+=1
print(count)

# n = 24
def get_subs(n):
    count = 0
    while n != '0':
        digits = [int(i) for i in n]
        max_digit = max(digits)
        n = int(n) - max_digit
        n = str(n)
        count += 1
    return count

if __name__ == '__main__':
     n = input()
     print(get_subs(n))

n=int(input())
k=0
while n:n-=int(max(str(n)));k+=1
print(k)

n = int(input())
steps=0
while n != 0:
    n -= max([int(k) for k in str(n)])
    steps += 1
print(steps)

s = int(input())
count = 0
while s > 0:
    s -= int(max(str(s)))
    count += 1
print(count)

n = int(input())
if 10 > n > 0:
    print(1)
    exit(0)
elif n == 0:
    print(0)
    exit(0)
dp = [2 for i in range(n)]
dp[0] = n
z = 1
while True:
    dp[z] = dp[z-1] - int(max(str(dp[z-1])))
    if dp[z] == 0:
        break
    z = z + 1
print(z)

from collections import Counter

def main():
    n = int(input())
    dp = Counter()

    elms = [n]
    dp[n] = 0

    while elms:
        e = elms.pop()
        m = max([int(c) for c in str(e)])
        if m > 0:
            if dp[e] + 1 < dp[e - m] or dp[e - m] == 0:
                dp[e - m] = dp[e] + 1
                elms.append(e - m)

    print(dp[0])

if __name__ == '__main__':
    main()

import sys
sys.setrecursionlimit(15000000)
def solve():
    n = int(input())
    mem = [1000000] * (n + 1)
    mem[0] = 0
    for i in range(1, n + 1):
        ncopy = i
        while ncopy > 0:
            last = ncopy % 10
            ncopy //= 10
            if last != 0 and i - last >= 0: mem[i] = min(mem[i], 1 + mem[i - last])
    print(mem[n])

if sys.hexversion == 50594544 : sys.stdin = open("test.txt")
solve()

num = int(input())

count = 0
while num != 0:
    lst = [int(i) for i in str(num)]
    num -= max(lst)
    count += 1

print(count)

i = input()
x = int(i)
cont = 0
while x:
    x -= int(max(i))
    i = str(x)
    cont += 1
print(cont)

import math
import sys

def solve(n):
    counter = 0
    while n!=0:
        num = str(n)
        num = set(num)
        max_digit = 0
        for x in num:
            if int(x) > max_digit:
                max_digit = int(x)
        n -= max_digit
        counter += 1
    return counter

def s():
    n = int(input())
    print(solve(n))

s()

n,k=int(input()),0
while n:n-=int(max(str(n)));k+=1
print(k)

def find(s):
    i = 9
    while s.find(str(i), 0, len(s)+1)==-1:
        i = i - 1
    s = str(int(s) - i)
    return s

n = int(input())
if (n==0):
    print(0)
    exit(0)
s1 = str(n)
ans = 0
while int(find(s1))!= 0:
    s1 = find(s1)
    ans = ans + 1
print(ans+1)

def dsolve(m):

    memo = {0: 0}

    def solve(k):
        l = len(str(k))
        if k in memo.keys():
            return memo[k]
        elif len(str(k)) == 1:
            memo[k] = 1
            return 1
        else:
            p = 1 + min([solve(k - int(c)) for c in str(k) if int(c)])
            memo[k] = p
            return p

    for i in range(m + 1):
        solve(i)

    return memo[m]

n = int(input())
print(dsolve(n))

n, k = int(input()), 0

while n:
    n, k = n - int(max(str(n))), k + 1

print(k)

n=int(input())
l=list(str(n))
n=int(n)
c=0
while n!=0:
    m=max(list(str(n)))
    n-=int(m)
    c+=1

print(c)

n=input()
ans=0
while(max(n)!="0"):
    t=max(n)
    k=int(n)-int(t)
    n=str(k)
    ans+=1
print(ans)

sums = int(input())
count = 0
while sums!=0:
    stringg = str(sums)
    maxi = max(stringg)
    sums = sums - int(maxi)
    count = count + 1
print(count)

def countways(n):
    if (n == 1):
        return 0;
    elif (n % 2 == 0):
        return 1 + countways(n / 2);
    else:
        return 1 + min(countways(n - 1),
                    countways(n + 1));

def max_digit(n):
    x=[]
    n=str(n)
    for i in range(0,len(n)):
        x.append(int(n[i]))
    c=int(max(x))
    return c

n=int(input())
y=0
while n!=0:
    x=max_digit(n)
    n=n-int(x)
    y+=1
print(y)

def maxx(n):
    l=[]
    while(n>0):
        l.append(n%10)
        n = int(n/10)
    return max(l)
n =int(input())
j=0
while(n>0):
    n = n- maxx(n)
    j+=1
print(j)

n = input()
tmp = int(n)
i = 0
while tmp != 0:
    sub = max([int(x) for x in str(tmp)])
    tmp -= sub
    #print(tmp)
    i += 1
print(i)

n=int(input())
res=0
while n!=0:
    mx=0
    for i,x in enumerate(str(n)):
        if int(x)>mx:mx=int(x)
    n-=mx
    res+=1
print(res)

n = int(input())
ans = 0
while n>0:
    i = n
    s = 0
    while i>0:
        s = max(s,i%10)
        i=i//10
    ans+=1
    n-=s

print(ans)

n=int(input())
count=0
while n!=0:
    n-=max(list(map(int,str(n))))
    count+=1
print(count)

n,k=int(input()),0
while n:
    n-=int(max(str(n)))
    k+=1
print(k)
#python ki jai ho :p

num=int(input())
ans=0
while(num!=0):
    L=list(str(num))
    d=int(max(L))
    num-=d
    ans+=1
print(ans)

n = int(input())
k = 0
while n > 0:
    n -= int(max(str(n)))
    k += 1
print(k)

n = input()
num = int(n)
count=1
if num==0:
    print(0)
else:
    while num >=10 :
        num-= int(max(list(n)))
        count+=1
        n= str(num)
    print(count)

mem = {}

def compute_count(pmax, re):
    global mem
    ore = re

    if (pmax, re) in mem:
        return mem[(pmax, re)]

    numdig = len(str(re))

    if numdig == 1:
        mem[(pmax, ore)] = 1, min(0, re-pmax)
        return 1, min(0, re-pmax)

    sc = 0
    while re > 0:
        s = str(re).zfill(numdig)
        nmax = max(pmax, int(s[0]))
        newre = int(s[1:])
        cnt, left = compute_count(nmax, newre)

        sc += cnt
        re -= newre
        re += left

    mem[(pmax, ore)] = sc, re
    return sc, re
x=int(input())
if x:
    print(compute_count(0,x )[0])
else:
    print(0)

n, counter = int(input()), 0
while n > 0:
    n -= int(max(str(n)))
    counter += 1

print(counter)

n = int(input())

count = 0
while n:
	n -= max(list(map(int,str(n))))
	count += 1

print(count)

n,k=int(input()),0
while n:n-=int(max(str(n)));k+=1
print(k)

def maxEl(n):
    max1=n%10
    while(n):
        tmp=n%10
        if tmp>max1:
            max1=tmp
        n/=10
    return max1
def main():
    k,n=0,input()
    while(n):
        n-=maxEl(n)
        k=k+1
    print(k)
main()

n = int(input())
def getMaxDigit(i):
    s = str(i)
    x = int(s[0])
    for c in s:
        x = max(int(c),x)
        if(x == 9):
            return x
    return x
count = 0
while(n != 0):
    n -= getMaxDigit(n)
    count += 1
print(count)

n = int(input())
count = 0
while n != 0:
    d = max(int(i) for i in str(n))
    n = n - d
    count += 1
print(count)

n = int(raw_input())

def figures(k):
    l = set([])
    while k>0:
        h = k%10
        if h!=0:
            l.add(h)
        k = k//10
    return l

oper = 0
num = n
while num>0:
    figs = figures(num)
    num = num - max(figs)
    oper+=1

print oper

m = int(input())
a = 0
while(m > 0):
    m -= int(max([int(i) for i in str(m)]))
    a += 1
print(a)

num = int(input())
count = 0
while num > 0:
    num -= int(max(list(str(num))))
    count += 1
print(count)

n=int(input())
f=0
while (n>0):
    f+=1
    n-=max(k-int(10e16)*(k==0) for k in set(map(int,str(n))))
print f

n = int(input())
count = 0

while n:
    n -= int(max(str(n)));
    count += 1

print(count)

#ROUNIAAUDI
y=int(input())
c=0
while y!=0:
    y-=int(max(str(y)))
    c+=1
print(c)

n = int(input())

def naive(n):
	c=0
	#print(n,end='\t')
	while n!=0:
		c+=1
		n-=max([int(x) for x in list(str(n))])
		#print(n)
	print(c)

# d=dict()
# d[0]=0
# def dp(n):
# 	if(n==0):
# 		return 0
# 	s=[int(x) for x in list(str(n))]
# 	minimo=n
# 	s=max(s)
# 	temp = n - s
# 	return dp(temp)+1

# for x in range(1,10,1):
# 	naive(x)
# for x in range(10,100,10):
# 	naive(x)
# for x in range(100,1000,100):
# 	naive(x)
# for x in range(1000,10000,1000):
# 	naive(x)
# for x in range(5000,6000,100):
# 	naive(x)

naive(n)

n = input()
count = 0
while(n > 0):
    n -= int(max(str(n)))
    count += 1
print count

a=input()
a=list(a)
count=0
while int(''.join(a))>0:
    k=max(a)
    a=int(''.join(a))-int(k)
    a=str(a)
    count+=1
    a=list(a)
print(count)

t = int(input())
c = 0
while t!=0:
    c+=1
    t = t-int(max(str(t)))
print(c)

n = int(input())

def maxDigit(a):
  x = 9
  while x > 0:
    if str(x) in str(a):
      return x
    else:
      x -= 1
  return 0

memo = 0
while n != 0:
  n = n - maxDigit(n)
  memo += 1

print(memo)

a=int(input())
i=0
while a!=0:
	i+=1
	x=max(list(map(int,list(str(a)))))
	a-=x
print(i)

n=int(input())
k=0
while n>0:
    n-=int(max(str(n)))
    k+=1
print(k)

import sys
def calc(n):
    global cnt
    if n == 0:
        return 0
    elif n < 10:
        cnt += 1
        return 0
    else:
        digit = '0'
        for dig in str(n):
            if dig > digit:
                digit = dig
        digit = int(digit)
        #print '!!!=' + str(digit)

        cnt += 1
        return n-digit

def calcMin(n):
    if n == 0:
        return 0
    elif n < 10:
        return 1
    elif n < 100:
        d1 = n / 10
        d2 = n % 10

    else:
        return 'hz'
def solve(n):
    #return calcMin(n)
    #data = {}
    global cnt
    cnt = 0
    while True:
        n = calc(n)
        if n==0:
            break
    return cnt

n = int(sys.stdin.readline())

print solve(n)

def findMax(st):
    a=['0','1','2','3','4','5','6','7','8','9']
    m=a[0]
    for letter in a:
        if letter in st:
            if int(letter)>int(m):
                m=letter
    return int(m)

s=raw_input()
b=int(s)
count=0
while b:
    sub=findMax(s)
    b-=sub
    s=str(b)
    count+=1
print count

n=input();

co=0
while(n>0):
	ma='0'
	a=str(n);
	for i in a:
		if(ma<i):
			ma=i
	kk=int(ma)
	#print kk
	n-=kk
	co+=1

print co

memoization_table = {}

def compute_count(previous_max, rest):
    global memoization_table
    original_rest = rest

    if (previous_max, rest) in memoization_table:
        return memoization_table[(previous_max, rest)]

    num_digits = len(str(rest))

    if num_digits == 1:
        memoization_table[(previous_max, original_rest)] = 1, min(0, rest-previous_max)
        return 1, min(0, rest-previous_max)

    sum_count = 0
    while rest > 0:
        s = str(rest).zfill(num_digits)
        new_max = max(previous_max, int(s[0]))
        new_rest = int(s[1:])
        count, leftover = compute_count(new_max, new_rest)

        sum_count += count
        rest -= new_rest
        rest += leftover

    memoization_table[(previous_max, original_rest)] = sum_count, rest
    return sum_count, rest

print(compute_count(0, int(input()))[0])

n = input()
count = 0
while(n % 10 != 0):
    n -= int(max(str(n)))
    count += 1
count += 2 * (n / 10)
print count

import time
def lucky(n):
    if n == 0:
        return 0
    if len(str(n)) == 1:
        return 1
    return 2*(n/10)+1
import sys

print lucky(int(sys.stdin.readline()))

def lucky(n):
    m = str(n)
    t = '987654321'
    t1 = 0
    count = 0
    while True:
        t1 = 0
        if len(m)==1:
            return count + 1
        for i in range(9):
            if t[i] in m:
                n -= int(t[i])
                m = str(n)
                count += 1
                break
    return count

import sys

print lucky(int(sys.stdin.readline()))

import time
def lucky(n):
    if n == 1:
        return 0
    if len(str(n)) == 1:
        return 1
    return 2*(n/10)+1
import sys

print lucky(int(sys.stdin.readline()))

import time
def lucky(n):
    if n == 0:
        return 0
    if len(str(n)) == 1:
        return 1
    if n%10 == 0:
        return 2*(n/10)
    return 2*(n/10)+1
import sys

print lucky(int(sys.stdin.readline()))

memoization_table = {}

def compute_count(previous_max, rest):
    global memoization_table
    original_rest = rest

    if (previous_max, rest) in memoization_table:
        return memoization_table[(previous_max, rest)]

    num_digits = len(str(rest))

    if num_digits == 1:
        memoization_table[(previous_max, original_rest)] = 1, min(0, rest-previous_max)
        return 1, min(0, rest-previous_max)

    sum_count = 0
    while rest > 0:
        s = str(rest).zfill(num_digits)
        new_max = max(previous_max, int(s[0]))
        new_rest = int(s[1:])
        count, leftover = compute_count(new_max, new_rest)

        sum_count += count
        rest -= new_rest
        rest += leftover

    memoization_table[(previous_max, original_rest)] = sum_count, rest
    return sum_count, rest

n=int(input())
ans,not_ans=compute_count(0,n)
print(ans)

from sys import stdin
import re
input_ = stdin.readline

magic_num  = input_()

def func(magic_num,operation=0):
    operation = operation
    max_num  = max([int(x) for x in magic_num.strip()])
    substraction = int(magic_num) - max_num
    if substraction == 0:
        return operation+1
    else:
        return func(str(substraction),operation+1)

print(func(magic_num))

s = input()
r = 0
while 1:
    l = list(s)
    d = list(map(int, s))
    n = ''.join(l)
    m = int(n)
    f = max(d)
    m = m-f
    r += 1
    s = str(m)
    if m<=0:
        break
print(r)

#Ashish Sagar
n=input()
s=list(n)
if n!='0':
    for i in range(len(s)):
        s[i]=int(s[i])
    if max(s)>(s[-1]):
        s[-1]=0
    else:
        s[-1]=5
    z=""
    for i in range(len(s)):
        z+=str(s[i])
    z=int(z)
    print(z//5)
else:
    print(0)

#Ashish Sagar
n=input()
s=list(n)
for i in range(len(s)):
    s[i]=int(s[i])
if max(s)>(s[-1]):
    s[-1]=0
else:
    s[-1]=5
z=""
for i in range(len(s)):
    z+=str(s[i])
z=int(z)
print(z//5)

#Ashish Sagar
n=input()
s=list(n)
for i in range(len(s)):
    s[i]=int(s[i])
if s[-1]!=0:
    s[-1]=5
z=""
for i in range(len(s)):
    z+=str(s[i])
z=int(z)
print(z//5)

def find_ans(n):
    if n%10==0:
        print(n//5)
    else:
        n=n-n%10
        print(1+(n//5))

find_ans(int(input()))

def menha(n):
    num=0
    while n%10!=0:
        p=int(max(list(str(n))))
        n-=p
        num+=1
    return (num,n)

def find_ans(n):
    numm,n=menha(n)
    print(numm+n//5)
find_ans(int(input()))

def menha(n):
    num=0
    while n%10!=0:
        p=int(max(list(str(n))))
        n-=p
        num+=1
    return (num,n)

def find_ans(n):
    numm,n=menha(n)
    print(numm+1+n//5)
find_ans(int(input()))

from math import *
from copy import *
from string import *				# alpha = ascii_lowercase
from random import *
from sys import stdin
from sys import maxsize
from operator import *				# d = sorted(d.items(), key=itemgetter(1))
from itertools import *
from collections import Counter		# d = dict(Counter(l))
import math

def bin1(l,r,k,t,b,val,ans):
	if(l>r):
		return ans
	else:
		mid=(l+r)//2
		v=k**mid
		if(v==val):
			return v
		elif(v>val):
			ans=mid
			return bin1(mid+1,r,k,t,b,val,ans)
		else:
			return bin1(l,mid-1,k,t,b,val,ans)

def bin2(l,r,k,t,b,val,ans):
	if(l>r):
		return ans
	else:
		mid=(l+r)//2
		v=t*(k**mid)+b*(mid)
		if(v==val):
			return v
		elif(v>val):
			ans=mid
			return bin2(l,mid-1,k,t,b,val,ans)
		else:
			return bin2(mid+1,r,k,t,b,val,ans)

def SieveOfEratosthenes(n):

    # Create a boolean array "prime[0..n]" and initialize
    #  all entries it as true. A value in prime[i] will
    # finally be false if i is Not a prime, else true.
    prime = [True for i in range(n+1)]
    p = 2
    while (p * p <= n):

        # If prime[p] is not changed, then it is a prime
        if (prime[p] == True):

            # Update all multiples of p
            for i in range(p * p, n+1, p):
                prime[i] = False
        p += 1
    l=[]
    for i in range(2,n+1):
    	if(prime[i]):
    		l.append(i)
    return l
def bin(l,r,ll,val):
	if(l>r):
		return -1
	else:
		mid=(l+r)//2
		if(val>=ll[mid][0] and val<=ll[mid][1]):
			return mid
		elif(val<ll[mid][0]):
			return bin(l,mid-1,ll,val)
		else:
			return bin(mid+1,r,ll,val)
def deci(n):
	s=""
	while(n!=0):
		if(n%2==0):
			n=n//2
			s="0"+s
		else:
			n=n//2
			s="1"+s
	return s
def diff(s1,s2):
	if(len(s1)<len(s2)):
		v=len(s1)
		while(v!=len(s2)):
			s1="0"+s1
			v=v+1
	else:
		v=len(s2)
		while(v!=len(s1)):
			s2="0"+s2
			v=v+1
	c=0
	for i in range(len(s1)):
		if(s1[i:i+1]!=s2[i:i+1]):
			c=c+1
	return c
from sys import stdin, stdout
def fac(a,b):
	v=a
	while(a!=b):
		v*=a-1
		a=a-1
	return v
def bino(l,r,n):
	if(l>r):
		return -1
	else:
		mid=(l+r)//2
		val1=math.log((n/mid)+1,2)
		val2=int(val1)
		if(val1==val2):
			return val1
		elif(val1<1.0):
			return bino(l,mid-1,n)
		else:
			return bino(mid+1,r,n)

def binary(l,r,ll,val,ans):
	if(l>r):
		return ans
	else:
		mid=(l+r)//2
		if(val%ll[mid]==0):
			ans=ll[mid]
			return binary(l,mid-1,ll,val,ans)
		else:
			return binary(l,mid-1,ll,val,ans)
def odd(n,ans,s):
	if(n%2!=0 or n in s):
		return ans
	else:
		s.add(n)
		return odd(n//2,ans+1,s)

if __name__ == '__main__':
	dp=[]
	for i in range(1000001):
		dp.append(0)

	for i in range(len(dp)):
		if(i<10):
			dp[i]=1
		else:
			val=i
			count=0
			while(True):
				maxa=0
				s=str(val)
				for j in range(len(s)):
					if(int(s[j:j+1])>maxa):
						maxa=int(s[j:j+1])
				val-=maxa
				count+=1
				if(val<=len(dp)):
					dp[i]=count+dp[val]
					break
				else:
					continue
	# print(len(dp))
	n=int(input())
	if(n<=len(dp)):
		print(dp[n])
	else:
		val=n
		count=0
		while(True):
			maxa=0
			s=str(val)
			for j in range(len(s)):
				if(int(s[j:j+1])>maxa):
					maxa=int(s[j:j+1])
			val-=maxa
			count+=1
			if(val<=len(dp)):
				count=count+dp[val]
				break
			else:
				continue
		print(count)

n = int(input())
if n < 10:
    print(1)
    exit(0)
elif n == 0:
    print(0)
dp = [2 for i in range(n)]
dp[0] = n
z = 1
while True:
    dp[z] = dp[z-1] - int(max(str(dp[z-1])))
    if dp[z] == 0:
        break
    z = z + 1
print(z)

n = int(input())
s = 1
while n > 9:
    n -= max(map(int, str(n)))
    s += 1
print(s)

def find(s):
    i = 9
    while s.find(str(i), 0, len(s)+1)==-1:
        i = i - 1
    s = str(int(s) - i)
    return s

n = int(input())
s1 = str(n)
ans = 0
while int(find(s1))!= 0:
    s1 = find(s1)
    ans = ans + 1
print(ans+1)

def getMaxDigit(n,c):
    if(n==0):
        return c
    else:
        t = n
        l= []
        while(t):
            l.append(t%10)
            t /= 10
        c+=1
        return getMaxDigit(n-max(l),c)
n = int(input())
print(getMaxDigit(n,0))

def getMaxDigit(n,c):
    if(n==0):
        return c
    else:
        t = n
        m = -1
        while(t):
            if(t%10 > m):
                m = t %10
            t = t // 10
        c+=1
        print(n,m,n-m)
        return getMaxDigit(n-m,c)
n = int(input())
print(getMaxDigit(n,0))

def main():
    n = int(input())

    res = 20 * (n // 100)
    i = n % 100

    dec = False
    while i % 10 != 0 and i % 9 != 0:
        i -= 1
        dec = True

    if dec:
        res += 1

    if i % 10 == 0:
        m = i // 10
        res += 2 * m
    elif i % 9 == 0:
        m = i // 9
        res += 2 * m - 1

    print(res)

if __name__ == '__main__':
    main()

def main():
    n = int(input())
    res = 20 * (n // 100)
    i = n % 100

    while i % 10 != 0 and i % 9 != 0:
        m = max([int(c) for c in str(i)])
        i -= m
        res += 1

    if i == 0:
        print(res)
        return

    if i % 9 == 0:
        m = i // 9
        res += 2 * m - 1
    elif i % 10 == 0:
        m = i // 10
        res += 2 * m

    print(res)

if __name__ == '__main__':
    main()

def main():
    n = int(input())

    if n == 0:
        print(0)
        return

    res = 20 * (n // 100)
    i = n % 100

    while i % 10 != 0 and i % 9 != 0:
        m = max([int(c) for c in str(i)])
        i -= m
        res += 1

    if i % 9 == 0:
        m = i // 9
        res += 2 * m - 1
    elif i % 10 == 0:
        m = i // 10
        res += 2 * m

    print(res)

if __name__ == '__main__':
    main()

import math

lookup = {}

def solve(n,mini):
    key = n
    if n == 0:
        lookup[key] = 0
    else:
        if key not in lookup:
            if n > mini:
                return 10e18
            else:
                temp = str(n)
                temp = set(temp)
                mini = 10e18
                for i in temp:
                    if int(i) != 0:
                        num = int(i)
                        mini = min(mini,solve(n-num,mini)+1)
                lookup[key] = mini
    return lookup[key]

def s():
    n = int(input())
    print(solve(n,10e18))

s()

count = 0
n = int(input())
if n < 10:
	print(1)
	exit()
while n > 10 :

	t = n
	z = float("-inf")
	r = 1
	while t :
		r = r + 1
		t1 = t%10
		t = t//10
		z = max(z,t1)
	n = n - z
	count = count + 1
	# print(n)
print(count+2)

n = list(input())
# for i in range(len(n)):
#     n[i] = int(n[i])
# print(n)
# print(int(''.join(n)))

c = 0
while(True):
    if(len(n) == 1):
        break
    else:
        s = int(max(n))
        m = int(int(''.join(n)) - s)
        n = list(str(m))
        # print(n)
        c += 1
print(c + 1)

n=int(input())
y=[]
for i in str(n):
    y.append(int(i))

count=0
x=n%10
if max(y)==x and n!=0:
    count=1
else:
    count=0
n=n-x
print((n//10)*2+count)

n=int(input())
y=[]
for i in str(n):
    y.append(int(i))

count=0
x=n%10
if max(y)==x:
    count=1
else:
    count=0
n=n-x
print((n//10)*2+count)

n = int(input())
num=0
while True:
    x = list(map(int,str(n)))

    if x[-1]==0:
        num+= n//5
        break
    n-=max(x)
    num+=1
print(num)

n = input()
num = int(n)
count=1
while num >=10 :
    num-= int(max(list(n)))
    count+=1
    n= str(num)
print(count)

s=list(input())
cnt=0
while(True):
	k=sorted(s)
	maxx=int(k[-1])
	s=list(str(int(''.join(s))-maxx))
	cnt+=1
	if len(s)==1 and int(s[0])<=0:
		break
print(cnt)

import math

a  =int(input())

print(math.ceil(a/5))

n = int(input())
i = [int(x) for x in str(n)]
sum = 1
while True:
    n -= max(i)
    i = [int(x) for x in str(n)]
    if n == 0:
        break
    else:
        sum += 1
print(sum)

n = int(input())
i = [int(x) for x in str(n)]
sum = 0
while True:
    n -= max(i)
    i = [int(x) for x in str(n)]
    if n == 0:
        break
    else:
        sum += 1
print(sum + 1)

n = int(input())
i = [int(x) for x in str(n)]
sum = 0
while True:
    n -= max(i)
    sum += 1
    i = [int(x) for x in str(n)]
    if n == 0:
        break
print(sum)