Some country is populated by wizards. They want to organize a demonstration.There are n people living in the city, x of them are the wizards who will surely go to the demonstration. Other city people (n - x people) do not support the wizards and aren't going to go to the demonstration. We know that the city administration will react only to the demonstration involving at least y percent of the city people. Having considered the matter, the wizards decided to create clone puppets which can substitute the city people on the demonstration. So all in all, the demonstration will involve only the wizards and their puppets. The city administration cannot tell the difference between a puppet and a person, so, as they calculate the percentage, the administration will consider the city to be consisting of only n people and not containing any clone puppets. Help the wizards and find the minimum number of clones to create to that the demonstration had no less than y percent of the city people.

The first line contains three space-separated integers, n, x, y (1 ≤ n, x, y ≤ 104, x ≤ n) — the number of citizens in the city, the number of wizards and the percentage the administration needs, correspondingly. Please note that y can exceed 100 percent, that is, the administration wants to see on a demonstration more people that actually live in the city ( > n).

Print a single integer — the answer to the problem, the minimum number of clones to create, so that the demonstration involved no less than y percent of n (the real total city population).

NoteIn the first sample it is necessary that at least 14% of 10 people came to the demonstration. As the number of people should be integer, then at least two people should come. There is only one wizard living in the city and he is going to come. That isn't enough, so he needs to create one clone. In the second sample 10 people should come to the demonstration. The city has 10 wizards. They will all come to the demonstration, so nobody has to create any clones.

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

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

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

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

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())
import math
print (0 if x>=n*y/100 else math.ceil(n*y/100 - x))

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
# ♥
# اگه ایمان داری که روزای خوب تو راهن
# روزای خوب قطعا به سمتت میاد

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)

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

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)

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,input().split())
import math
if x >= n*y/100:
    print(0)
else:
    print(math.ceil(n*y/100 - x))

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)

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)

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 sys

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

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

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)

from math import ceil

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

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

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

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(int,input().split())
ans=math.ceil((y*n/100))
if x>=ans:
    print(0)
else:
    print(ans-x)

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

w = x

y /= 100
ans = 0

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

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

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)

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

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 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(' '))

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

print(max(0, f))

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

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())
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')

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

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

#!/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 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
a,b,c=map(int,input().split())
p=math.ceil((c*a)/100)
if p<=b:print(0)
else:print(p-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, raw_input().split())
u = math.floor((n * (float(y) / 100) + 0.9999))
print(max(0, int(u) - 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)

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

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 = [int(x) for x in raw_input().split()]

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

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

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

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

#!/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()

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

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

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

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

import sys

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

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

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

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

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)

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)

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

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 = [int(x) for x in raw_input().split()]

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

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)

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

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)

I=lambda:map(int, raw_input().split())
n,x,y=I()
print max((n*y+99)/100-x,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)

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

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

from sys import stdin

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

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

import math
n, x, y = map(int, input().split())
ans = max(0, math.ceil(y / 100 * n) - 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>y*1.0/100:
    print(0)
else:
    print int(math.ceil(1.0*(y*n-100*x)/(100)))

import math

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

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

import math

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

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)

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)


Yet another Armageddon is coming! This time the culprit is the Julya tribe calendar. The beavers in this tribe knew math very well. Smart Beaver, an archaeologist, got a sacred plate with a magic integer on it. The translation from Old Beaverish is as follows: "May the Great Beaver bless you! May your chacres open and may your third eye never turn blind from beholding the Truth! Take the magic number, subtract a digit from it (the digit must occur in the number) and get a new magic number. Repeat this operation until a magic number equals zero. The Earth will stand on Three Beavers for the time, equal to the number of subtractions you perform!"Distinct subtraction sequences can obviously get you different number of operations. But the Smart Beaver is ready to face the worst and is asking you to count the minimum number of operations he needs to reduce the magic number to zero.

The single line contains the magic integer n, 0 ≤ n.   to get 20 points, you need to solve the problem with constraints: n ≤ 106 (subproblem C1);  to get 40 points, you need to solve the problem with constraints: n ≤ 1012 (subproblems C1+C2);  to get 100 points, you need to solve the problem with constraints: n ≤ 1018 (subproblems C1+C2+C3).

Print a single integer — the minimum number of subtractions that turns the magic number to a zero.

NoteIn the first test sample the minimum number of operations can be reached by the following sequence of subtractions:  24 → 20 → 18 → 10 → 9 → 0

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())
count = 0
while n != 0:
    d = max(int(i) for i in str(n))
    n = n - d
    count += 1
print(count)

'''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

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)

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

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

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

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

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

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

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,k=int(input()),0
while n:n-=int(max(str(n)));k+=1
print(k)

n = int(input())

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

print(count)

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

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

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

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)

n=int(input())
count=0

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

print (count)

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

print(counter)

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

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:
    n -= int(max(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

n  = int(input())
s=0

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

print(s)

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)

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)

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)

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

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

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

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)

num = int(input())

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

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)

# -*- 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)

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)

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

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)

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)

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

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

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

print(k)

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

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

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)

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

#	!/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()

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

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

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

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)

s = int(input())
count = 0
while s > 0:
    s -= int(max(str(s)))
    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 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())
k=0
while n>0:
    n-=int(max(str(n)))
    k+=1
print(k)

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

print(ans)

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)

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())
steps=0
while n != 0:
    n -= max([int(k) for k in str(n)])
    steps += 1
print(steps)

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

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())
k=0
while n:n-=int(max(str(n)));k+=1
print(k)

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

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())
c=0
while(n>0):
	l=max(str(n))
	n=n-int(l)
	c+=1
print(c)

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

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 = input()
count = 0
while(n > 0):
    n -= int(max(str(n)))
    count += 1
print count

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)

n  = int(input())
s=0

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

print(s)

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

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)

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

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)

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

# 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()

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

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

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

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)

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

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

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)