Allen has a LOT of money. He has $n$ dollars in the bank. For security reasons, he wants to withdraw it in cash (we will not disclose the reasons here). The denominations for dollar bills are $1$, $5$, $10$, $20$, $100$. What is the minimum number of bills Allen could receive after withdrawing his entire balance?


-----Input-----

The first and only line of input contains a single integer $n$ ($1 \le n \le 10^9$).


-----Output-----

Output the minimum number of bills that Allen could receive.


-----Examples-----
Input
125

Output
3

Input
43

Output
5

Input
1000000000

Output
10000000



-----Note-----

In the first sample case, Allen can withdraw this with a $100$ dollar bill, a $20$ dollar bill, and a $5$ dollar bill. There is no way for Allen to receive $125$ dollars in one or two bills.

In the second sample case, Allen can withdraw two $20$ dollar bills and three $1$ dollar bills.

In the third sample case, Allen can withdraw $100000000$ (ten million!) $100$ dollar bills.

Difficulty: EASY
Tags: Dynamic programming

Greedy algorithms
Skill types: Dynamic programming

Greedy algorithms

Starter code:

Solutions:
n = int(input())
count = 0
count += n // 100
n = n % 100
count += n // 20
n = n % 20
count += n // 10
n = n % 10
count += n // 5
n = n % 5
print(count + n)


def retrieve_bills(amount):
	count = 0
	while amount != 0:
		if amount >= 100:
			quotient = amount // 100
			count += quotient
			amount = amount - quotient * 100
		elif amount >= 20:
			quotient = amount // 20
			count += quotient
			amount = amount - quotient * 20
		elif amount >= 10:
			quotient = amount // 10
			count += quotient
			amount = amount - quotient * 10
		elif amount >= 5:
			quotient = amount // 5
			count += quotient
			amount = amount - quotient * 5
		elif amount >= 1:
			quotient = amount // 1
			count += quotient
			amount = amount - quotient * 1
	return count
amount = int(input())
print(retrieve_bills(amount))


x = int(input(''))
c = 0
p = x / 100
if p >= 1:
	c = c + int(p)
	x = x % 100
p = x / 20
if p >= 1:
	c = c + int(p)
	x = x % 20
p = x / 10
if p >= 1:
	c = c + int(p)
	x = x % 10
p = x / 5
if p >= 1:
	c = c + int(p)
	x = x % 5
p = x / 1
if p >= 1:
	c = c + int(p)
	x = x % 1
print(c)


n = int(input())
count = 0
while n > 0:
	if n >= 100:
		count = count + int(n / 100)
		n = n % 100
	elif n >= 20:
		count = count + int(n / 20)
		n = n % 20
	elif n >= 10:
		count = count + int(n / 10)
		n = n - 10
	elif n >= 5:
		count = count + int(n / 5)
		n = n % 5
	elif n < 5:
		count = count + n
		n = 0
	else:
		break
print(count)


list = [100, 20, 10, 5, 1]
bill = int(input())
count = 0
a = 0
while not bill == 0:
	count = count + int(bill // list[a])
	bill = bill % list[a]
	a += 1
print(count)


bills = [100, 20, 10, 5, 1]
n = int(input())
ans = 0
for i in bills:
	if n == 0:
		print(ans)
		exit()
	ans += n // i
	n = n % i
print(ans)
exit()


l = [1, 5, 10, 20, 100]
n = int(input())
c = 0
while n > 0:
	if n % l[-1] != n:
		c = c + n // l[-1]
		n = n % l[-1]
	else:
		l.pop()
print(c)


n = int(input())
ch1 = n % 5
n = n // 5
ch5 = n % 2
n = n // 2
ch10 = n % 2
n = n // 2
ch20 = n % 5
n = n // 5
ch100 = n
print(ch1 + ch5 + ch10 + ch20 + ch100)


n = int(input())
res = 0
for e in [100, 20, 10, 5]:
	res += n // e
	n %= e
print(res + n)


n = int(input())
d = [100, 20, 10, 5, 1]
idx = 0
ans = 0
while n > 0:
	ans += n // d[idx]
	n = n % d[idx]
	idx += 1
print(ans)


import math
dollars = [100, 20, 10, 5, 1]

def solution(n):
	rest = n
	bills = 0
	for dollar in dollars:
		bills += int(rest / dollar)
		rest %= dollar
	print(bills)
solution(int(input()))


n = int(input())
res = 0
res += int(n / 100)
n = n % 100
res += int(n / 20)
n = n % 20
res += int(n / 10)
n = n % 10
res += int(n / 5)
n = n % 5
res += n
print(res)


n = int(input())
ans = 0
for x in (100, 20, 10, 5, 1):
	ans += n // x
	n %= x
print(ans)


N = int(input())
Counter = 0
Counter += N // 100
N %= 100
Counter += N // 20
N %= 20
Counter += N // 10
N %= 10
Counter += N // 5
N %= 5
Counter += N
print(Counter)


n = int(input())
hundred = n // 100
n = n % 100
twenty = n // 20
n = n % 20
ten = n // 10
n = n % 10
five = n // 5
n = n % 5
one = n
total = hundred + twenty + ten + five + one
print(total)


n = int(input())
count = n // 100
n = n % 100
count += n // 20
n = n % 20
count += n // 10
n = n % 10
count += n // 5
n = n % 5
count += n // 1
print(count)


n = int(input())
liste = (100, 20, 10, 5, 1)
total = 0
for i in liste:
	total += n // i
	n = n % i
print(total)


n = int(input())
arr = [100, 20, 10, 5, 1]
c = 0
for a in arr:
	c += n // a
	n %= a
print(c)


n = int(input())
tot = 0
tot += n // 100
n %= 100
tot += n // 20
n %= 20
tot += n // 10
n %= 10
tot += n // 5
n %= 5
tot += n // 1
n %= 1
print(tot)


menh_gia = [100, 20, 10, 5, 1]
n = int(input())
count = 0
for gia in menh_gia:
	x = n // gia
	count += x
	n = n - x * gia
print(count)


def get_denom(money, start, denom):
	if money == 0:
		return 0
	elif money >= denom[start]:
		return money // denom[start] + get_denom(money % denom[start], start + 1, denom)
	else:
		return get_denom(money, start + 1, denom)
n = int(input())
denom = [100, 20, 10, 5, 1]
print(get_denom(n, 0, denom))


def solve(n):
	candidates = [1, 5, 10, 20, 100]
	count = 0
	while n > 0:
		candidate = candidates.pop()
		count += n // candidate
		n = n % candidate
	return count

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


a = int(input())
s = 0
if a >= 100:
	s = s + a // 100
	a = a % 100
if a >= 20:
	s = s + a // 20
	a = a % 20
if a >= 10:
	s = s + a // 10
	a = a % 10
if a >= 5:
	s = s + a // 5
	a = a % 5
if a < 5:
	s = s + a
print(s)


a = [100, 20, 10, 5, 1]
n = int(input())

def f(n, x=0, y=0):
	s = a[y]
	x += n // s
	n %= s
	y += 1
	if y <= 4:
		return f(n, x, y)
	else:
		return x
print(f(n))


n = int(input())
cem = 0
vinte = 0
dez = 0
cinco = 0
um = 0
if n >= 100:
	cem = n // 100
	n = n % 100
if n >= 20:
	vinte = n // 20
	n = n % 20
if n >= 10:
	dez = n // 10
	n = n % 10
if n >= 5:
	cinco = n // 5
um = n % 5
notas = cem + vinte + dez + cinco + um
print(notas)


n = int(input())
ls = [100, 20, 10, 5, 1]
count = 0
while n >= 1:
	if n >= 100:
		count += n // 100
		n = n % 100
	if n >= 20:
		count += n // 20
		n = n % 20
	if n >= 10:
		count += n // 10
		n = n % 10
	if n >= 5:
		count += n // 5
		n = n % 5
	if n >= 1:
		count += n // 1
		n = n % 1
print(count)


n = int(input())
answer = (n - n % 100) / 100
n = n % 100
answer += (n - n % 20) / 20
n = n % 20
answer += (n - n % 10) / 10
n = n % 10
answer += (n - n % 5) / 5
n = n % 5
answer += (n - n % 1) / 1
n = n % 1
print(int(answer))


N = int(input())
L = [1, 5, 10, 20, 100]
i = len(L) - 1
c = 0
while True:
	if i == -1:
		break
	if L[i] <= N:
		d = N // L[i]
		N = N - d * L[i]
		c += d
	else:
		i -= 1
print(c)


n = int(input())
s = n // 100
n = n % 100
s = s + n // 20
n = n % 20
s = s + n // 10
n = n % 10
s = s + n // 5
n = n % 5
s = s + n
print(s)


n = int(input())
denominations = [1, 5, 10, 20, 100]
count = 0
i = len(denominations) - 1
while n and i > -1:
	count += n // denominations[i]
	n %= denominations[i]
	i -= 1
print(count)


M = [100, 20, 10, 5, 1]
n = int(input())
count = 0
for m in M:
	if m <= n:
		a = int(n / m)
		count += a
		n = n % (a * m)
print(count)


a = int(input())
b = [100, 20, 10, 5, 1]
notes = 0
for i in range(len(b)):
	notes += a // b[i]
	a = a % b[i]
print(notes)


while True:
	try:

		def solution(bill):
			netB = 0
			amunt = 0
			if bill > 10 ** 4:
				netB = (bill - 10 ** 4) % 100
				amunt = (bill - 10 ** 4) // 100
				bill = 10 ** 4
			bill += netB
			coins = [1, 5, 10, 20, 100]
			dp = [10 ** 13] * (bill + 1)
			dp[0] = 0
			for b in range(1, bill + 1, 1):
				for c in range(5):
					if b >= coins[c]:
						dp[b] = min(dp[b], dp[b - coins[c]] + 1)
			print(dp[bill] + amunt)

		def read():
			bill = int(input())
			solution(bill)
		if __name__ == '__main__':
			read()
	except EOFError:
		break


n = int(input())
coins = [100, 20, 10, 5, 1]
i = 0
noc = 0
while n:
	if n >= coins[i]:
		noc += n // coins[i]
		n = n % coins[i]
	i += 1
print(noc)


n = int(input())
denom = [1, 5, 10, 20, 100]

def val_find(n):
	if n in denom:
		return n
	else:
		for i in range(len(denom) - 1):
			if denom[i] <= n and denom[i + 1] >= n:
				return denom[i]
	return 100
ans = 0
while n > 0:
	x = val_find(n)
	temp = n // x
	ans += temp
	n = n % x
print(ans)


n = int(input())
a = n % 100
b = n // 100
c = a % 20
d = a // 20
e = c % 10
f = c // 10
g = e % 5
h = e // 5
i = g // 1
print(int(b + d + f + h + i))


n = int(input())
arr = [100, 20, 10, 5, 1]
value = 0
for i in range(5):
	value += n // arr[i]
	n %= arr[i]
print(value)


values = [100, 20, 10, 5, 1]
n = int(input())
count = 0
for v in values:
	count += n // v
	n = n % v
print(count)


balance = int(input())
notes = 0
currentbal = balance
l = [100, 20, 10, 5, 1]
for i in l:
	notes += currentbal // i
	currentbal = currentbal % i
print(notes)


amt = int(input())
ans = 0
l = [1, 5, 10, 20, 100]
i = -1
while i != -6:
	ans += amt // l[i]
	amt -= amt // l[i] * l[i]
	i -= 1
print(ans)


s = [1, 5, 10, 20, 100]
s = s[::-1]
m = 0
x = int(input())
for n in s:
	if int(x / n) != 0:
		m += int(x / n)
	x = x % n
print(m)


n = int(input())
a = 0
for i in (100, 20, 10, 5, 1):
	a += n // i
	n = n % i
print(a)


import math
n = int(input())
a = math.floor(n / 100)
b = math.floor((n - 100 * a) / 20)
c = math.floor((n - 100 * a - 20 * b) / 10)
d = math.floor((n - 100 * a - 20 * b - 10 * c) / 5)
e = math.floor((n - 100 * a - 20 * b - 10 * c - 5 * d) / 1)
print(int(a + b + c + d + e))


n = int(input())
ans = 0
for i in (100, 20, 10, 5, 1):
	ans += n // i
	n = n % i
	if n == 0:
		break
print(ans)


n = int(input())
i = 0
Billets = [100, 20, 10, 5, 1]
for j in Billets:
	while n >= j:
		n = n - j
		i = i + 1
print(i)


amt = int(input())
count = 0
if amt // 100 >= 1:
	count += amt // 100
	amt = amt % 100
if amt // 20 >= 1:
	count += amt // 20
	amt = amt % 20
if amt // 10 >= 1:
	count += amt // 10
	amt = amt % 10
if amt // 5 >= 1:
	count += amt // 5
	amt = amt % 5
if amt // 1 >= 1:
	count += amt // 1
	amt = amt % 1
print(count)


n = int(input())
c = 0
if n >= 100:
	c += n // 100
	n = n % 100
if n >= 20:
	c += n // 20
	n = n % 20
if n >= 10:
	c += n // 10
	n = n % 10
if n >= 5:
	c += n // 5
	n = n % 5
if n >= 1:
	c += n
print(c)


n = int(input())
nos = [100, 20, 10, 5, 1]
total = 0
i = 0
while n != 0:
	total += n // nos[i]
	n = n % nos[i]
	i += 1
print(total)


n = int(input())
p = n // 100
q = n % 100
p1 = q // 20
q1 = q % 20
p2 = q1 // 10
q2 = q1 % 10
p3 = q2 // 5
q3 = q2 % 5
p4 = q3 // 1
print(p + p1 + p2 + p3 + p4)


n = int(input())
(k, l) = ([1, 5, 10, 20, 100], 0)
for i in range(4, -1, -1):
	if k[i] < n and n > 0:
		if n >= 2 * k[i]:
			l += n // k[i]
			n %= k[i]
		else:
			l += 1
			n %= k[i]
	if k[i] == n and n > 0:
		l += n // k[i]
		n %= k[i]
print(l)


n = int(input())
m = 0
if n // 100:
	m += n // 100
	n -= n // 100 * 100
if n // 20:
	m += n // 20
	n -= n // 20 * 20
if n // 10:
	m += n // 10
	n -= n // 10 * 10
if n // 5:
	m += n // 5
	n -= n // 5 * 5
m += n
print(m)


n = int(input())
c = 0
c += int(n / 100)
c += int(n % 100 / 20)
c += int(n % 100 % 20 / 10)
c += int(n % 100 % 20 % 10 / 5)
c += int(n % 100 % 20 % 10 % 5)
print(c)


n = int(input())
x = 0
if n >= 100:
	y = n // 100
	x += y
	n = n - 100 * y
if n >= 20:
	y = n // 20
	x += y
	n = n - 20 * y
if n >= 10:
	y = n // 10
	x += y
	n = n - 10 * y
if n >= 5:
	y = n // 5
	x += y
	n = n - 5 * y
if n < 5:
	x += n
print(x)


l = [100, 20, 10, 5, 1]
val = int(input())
count = 0
for i in l:
	while val >= i:
		temp1 = val % i
		temp = val // i
		val = temp1
		count += temp
print(count)


n = int(input())
l = [100, 20, 10, 5, 1]
step = 0
for each in l:
	if n % each != n:
		step += n // each
		n = n % each
print(step)


n = int(input())
bill = [100, 20, 10, 5, 1]
num = 0
for i in bill:
	num += n // i
	n = n % i
print(num)


n = int(input())
x = n // 100
n = n - x * 100
y = n // 20
n = n - y * 20
z = n // 10
n = n - z * 10
a = n // 5
n = n - a * 5
print(x + y + z + a + n)


N = int(input())
Sum = 0
Arr = [100, 20, 10, 5, 1]
for i in range(5):
	if int(N / Arr[i]) > 0:
		Sum = Sum + int(N / Arr[i])
		N = N - int(N / Arr[i]) * Arr[i]
print(Sum)


money = int(input())
bills = 0
if money >= 100:
	bills += money // 100
	money -= bills * 100
if money >= 20:
	bills += money // 20
	money -= money // 20 * 20
if money >= 10:
	bills += 1
	money -= 10
if money >= 5:
	bills += 1
	money -= 5
print(bills + money)


x = int(input())
count = 0
while x != 0:
	if x >= 100:
		count += x // 100
		x = x - 100 * (x // 100)
	elif x >= 20:
		count += x // 20
		x = x - 20 * (x // 20)
	elif x >= 10:
		count += x // 10
		x = x - 10 * (x // 10)
	elif x >= 5:
		count += x // 5
		x = x - 5 * (x // 5)
	elif x >= 1:
		count += x // 1
		x = x - 1 * (x // 1)
print(count)


n = int(input())
notas = [100, 20, 10, 5, 1]
resu = 0
for e in notas:
	resu += n // e
	n = n % e
print(resu)


n = int(input())
count = 0
D = [100, 20, 10, 5, 1]
for i in D:
	if n / i != 0:
		count += int(n / i)
		n -= int(n / i) * i
print(count)


n = int(input())
hs = n // 100
ans = 0
ans += hs
n = n % 100
ts = n // 20
ans += ts
n = n % 20
tens = n // 10
ans += tens
n = n % 10
fives = n // 5
ans += fives
n = n % 5
ans += n
print(ans)


def get_ints():
	return [int(n) for n in input().split()]

def get_floats():
	return [float(n) for n in input().split()]
a = get_ints()
assert len(a) == 1
n = a[0]
res = 0
nominals = [100, 20, 10, 5, 1]
for nm in nominals:
	res += n // nm
	n = n % nm
print(res)


n = int(input())
a = 0
c = 0
e = 0
t = 0
if n >= 100:
	a = n // 100
	n = n - a * 100
if n >= 20:
	c = n // 20
	n = n - c * 20
if n >= 10:
	e = n // 10
	n = n - e * 10
if n >= 5:
	t = n // 5
	n = n - t * 5
res = a + c + e + t + n
print(res)


t = int(input())
r = 0
for i in (100, 20, 10, 5, 1):
	r += t // i
	t = t % i
print(r)


from __future__ import division, print_function
from collections import *
from math import *
from itertools import *
import os
import 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

def main():
	n = int(input())
	dollar = [100, 20, 10, 5, 1]
	count = 0
	while n:
		for i in dollar:
			if n - i >= 0:
				n -= i
				count += 1
				break
	print(count)
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):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		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))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')

def print(*args, **kwargs):
	(sep, file) = (kwargs.pop('sep', ' '), 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', '\n'))
	if kwargs.pop('flush', False):
		file.flush()
if sys.version_info[0] < 3:
	(sys.stdin, sys.stdout) = (FastIO(sys.stdin), FastIO(sys.stdout))
else:
	(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
main()


def main():
	bills = [100, 20, 10, 5, 1]
	money = int(input())
	count = 0
	b = 0
	while money > 0 and b < len(bills):
		if bills[b] <= money:
			a = money // bills[b]
			count += a
			money -= a * bills[b]
		else:
			b += 1
	print(count)
main()


PIEZAS = list(map(int, input().split()))
valor = PIEZAS[0]
contdebilletes = 0
while valor != 0:
	if valor >= 100:
		contdebilletes = contdebilletes + valor // 100
		valor = valor % 100
	if valor >= 20:
		contdebilletes = contdebilletes + valor // 20
		valor = valor % 20
	if valor >= 10:
		contdebilletes = contdebilletes + valor // 10
		valor = valor % 10
	if valor >= 5:
		contdebilletes = contdebilletes + valor // 5
		valor = valor % 5
	if valor >= 1:
		contdebilletes = contdebilletes + valor // 1
		valor = valor % 1
print(contdebilletes)


s = int(input())
k = 0
k += s // 100
s = s % 100
k += s // 20
s = s % 20
k += s // 10
s = s % 10
k += s // 5
s = s % 5
k += s
print(k)


n = int(input())
output = 0
output += int(n / 100)
n %= 100
output += int(n / 20)
n %= 20
output += int(n / 10)
n %= 10
output += int(n / 5)
n %= 5
output += n
print(output)


bills = [100, 20, 10, 5, 1]
money = int(input())
nBills = 0
while money >= int(10000000.0):
	money = money - int(10000000.0)
	nBills = nBills + int(100000.0)
while money >= int(10000.0):
	money = money - int(10000.0)
	nBills = nBills + 100
while money > 0:
	for b in bills:
		if b <= money:
			money = money - b
			nBills = nBills + 1
			break
		else:
			pass
print(nBills)


dinheiro = int(input())
notas = [100, 20, 10, 5, 1]
num_notas = 0
for nota in notas:
	adicional = dinheiro // nota
	num_notas = num_notas + adicional
	dinheiro = dinheiro - adicional * nota
print(num_notas)


n = int(input())
counter = 0
while n != 0:
	if n % 100 == 0:
		counter += 1
		n -= 100
	elif n % 20 == 0:
		counter += 1
		n -= 20
	elif n % 10 == 0:
		counter += 1
		n -= 10
	elif n % 5 == 0:
		counter += 1
		n -= 5
	else:
		counter += 1
		n -= 1
print(counter)


def coinChange(n):
	c = 0
	coin_list = [100, 20, 10, 5, 1]
	for i in coin_list:
		if n >= i:
			d = n // i
			c += d
			n -= d * i
	print(c)
coinChange(int(input()))


n = 0
x = int(input())
n += x // 100
x = x % 100
n += x // 20
x = x % 20
n += x // 10
x = x % 10
n += x // 5
x = x % 5
n += x // 1
x = x % 1
print(n)


import math

def Numbill(m):
	bill = 0
	while m != 0:
		if math.floor(m / 100) >= 1:
			temp = math.floor(m / 100)
			m -= 100 * temp
			bill += temp
		elif math.floor(m / 20) >= 1:
			temp = math.floor(m / 20)
			m -= 20 * temp
			bill += temp
		elif math.floor(m / 10) >= 1:
			temp = math.floor(m / 10)
			m -= 10 * temp
			bill += temp
		elif math.floor(m / 5) >= 1:
			temp = math.floor(m / 5)
			m -= 5 * temp
			bill += temp
		elif math.floor(m / 1) >= 1:
			temp = math.floor(m / 1)
			m -= 1 * temp
			bill += temp
	return bill
m = int(input())
print(Numbill(m))


n = int(input())
r = 0
c = [100, 20, 10, 5, 1]
for x in c:
	r += n // x
	n %= x
print(r)


n = int(input())
s = [100, 20, 10, 5, 1]
count = 0
for i in (100, 20, 10, 10, 5, 1):
	count += n // i
	n = n % i
print(count)


n = int(input())
p = 0
p += n // 100
n -= n // 100 * 100
p += n // 20
n -= n // 20 * 20
p += n // 10
n -= n // 10 * 10
p += n // 5
n -= n // 5 * 5
p += n // 1
n -= n // 1 * 1
print(p)


n = int(input())
number_of_bill = 0
bill = [100, 20, 10, 5, 1]
for i in range(5):
	number_of_bill += int(n / bill[i])
	n = n % bill[i]
print(number_of_bill)


def main():
	N = int(input())
	ans = 0
	for i in [100, 20, 10, 5, 1]:
		x = N // i
		ans += x
		N = N - i * x
	print(ans)
main()


bills = [100, 20, 10, 5, 1]
cnt = 0
n = int(input())
ind = 0
while n > 0:
	while n >= bills[ind]:
		n -= bills[ind]
		cnt += 1
	ind += 1
print(cnt)


a = int(input())
b = a // 100
b1 = a % 100
c = b1 // 20
c1 = b1 % 20
f = c1 // 10
f1 = c1 % 10
d = f1 // 5
d1 = f1 % 5
e = d1 // 1
print(b + c + f + d + e)


n = int(input())
a = n // 100
n = n % 100
b = n // 20
n = n % 20
c = n // 10
n = n % 10
d = n // 5
n = n % 5
print(a + b + c + d + n)


n = int(input())
c = 0
while n != 0:
	if n > 99:
		n -= 100
	elif n > 19:
		n -= 20
	elif n > 9:
		n -= 10
	elif n > 4:
		n -= 5
	elif n > 0:
		n -= 1
	c += 1
print(c)


def countCurrency(amount):
	notes = [100, 20, 10, 5, 1]
	noteCounter = [0, 0, 0, 0, 0]
	s = 0
	for (i, j) in zip(notes, noteCounter):
		if amount >= i:
			j = amount // i
			amount = amount - j * i
			s += j
	return s
amount = int(input())
print(countCurrency(amount))


def go():
	n = int(input())
	data = [100, 20, 10, 5, 1]
	i = 0
	c = 0
	while n > 0:
		if data[i] <= n:
			x = n // data[i]
			n = n % data[i]
			c += x
		else:
			i += 1
	return c
print(go())


n = int(input())
b = [100, 20, 10, 5, 1]
ans = 0
for i in range(len(b)):
	if b[i] * (n // b[i]) != 0:
		ans += n // b[i]
	n -= b[i] * (n // b[i])
print(ans)


n = int(input())
a1 = n // 100
a2 = (n - a1 * 100) // 20
a3 = (n - a1 * 100 - a2 * 20) // 10
a4 = (n - a1 * 100 - a2 * 20 - a3 * 10) // 5
a5 = (n - a1 * 100 - a2 * 20 - a3 * 10 - a4 * 5) // 1
print(a1 + a2 + a3 + a4 + a5)


a = int(input())
ost = a
flag = False
flag2 = False
r = 0
s = 0
while flag == False:
	if ost // 100 >= 1:
		while ost > 100:
			r += ost // 100
			ost = ost - ost // 100 * 100
			flag2 = True
		if flag2 == False:
			r += 1
	elif ost // 20 >= 1:
		r += 1
		ost = ost - 20
	elif ost // 10 >= 1:
		r += 1
		ost = ost - 10
	elif ost // 5 >= 1:
		r += 1
		ost = ost - 5
	elif ost < 5 and ost > 0:
		r += 1
		ost -= 1
	elif ost == 0:
		flag = True
print(r)


n = int(input())
if n == 0:
	print('0')
else:
	k = 0
	k += n // 100
	n = n % 100
	k += n // 20
	n = n % 20
	k += n // 10
	n = n % 10
	k += n // 5
	n = n % 5
	k += n
	print(int(k))


n = int(input())
list = [100, 20, 10, 5, 1]
k = 0
for i in range(5):
	k += n // list[i]
	n = n % list[i]
print(k)


a = int(input())
n = 0
import math
b = math.floor(a / 100)
a = a - b * 100
n = n + b
b = math.floor(a / 20)
a = a - b * 20
n = n + b
b = math.floor(a / 10)
a = a - b * 10
n = n + b
b = math.floor(a / 5)
a = a - b * 5
n = n + b
b = math.floor(a / 1)
a = a - b * 1
n = n + b
print(n)


n = int(input())
z = n // 100
x = n // 100
n -= 100 * z
z = n // 20
x += z
n -= 20 * z
z = n // 10
x += z
n -= 10 * z
z = n // 5
x += z
n -= 5 * z
x += n
print(x)


n = int(input())
deno = [1, 5, 10, 20, 100]
res = []
cnt = int(n / 100)
n = int(n % 100)
i = 3
while i >= 0:
	while n >= deno[i]:
		n = n - deno[i]
		cnt += 1
	i -= 1
print(cnt)


(a, c) = (int(input()), 0)
c += a // 100
if a // 100 != a / 100:
	a -= 100 * (a // 100)
	c += a // 20
	if a // 20 != a / 20:
		a -= 20 * (a // 20)
		c += a // 10
		if a // 10 != a / 10:
			a -= 10 * (a // 10)
			c += a // 5
			if a // 5 != a / 5:
				a -= 5 * (a // 5)
				c += a // 1
print(c)


n = int(input())
i = 0
i += n // 100
n %= 100
i += n // 20
n %= 20
i += n // 10
n %= 10
i += n // 5
n %= 5
i += n
print(i)


n = int(input())
cnt = 0
while n:
	tmp = 0
	f = 0
	if n // 100 != 0:
		tmp = n // 100
		f = 100
	elif n // 20 != 0:
		tmp = n // 20
		f = 20
	elif n // 10 != 0:
		tmp = n // 10
		f = 10
	elif n // 5 != 0:
		tmp = n // 5
		f = 5
	else:
		tmp = n
		f = 1
	cnt += tmp
	n = n - tmp * f
print(cnt)


n = int(input())
a = [100, 20, 10, 5, 1]
ans = 0
for d in a:
	ans += n // d
	n %= d
print(ans)


n = input()
n = int(n)
a = [100, 20, 10, 5, 1]
count = 0
i = 0
while n > 0:
	if n >= a[i]:
		q = n // a[i]
		count = count + q
		n = n - q * a[i]
	i = i + 1
print(count)


a = int(input())
po = 0
if a >= 100:
	po = po + a // 100
	a = a % 100
if a >= 20:
	po = po + a // 20
	a = a % 20
if a >= 10:
	po = po + a // 10
	a = a % 10
if a >= 5:
	po = po + a // 5
	a = a % 5
if a >= 1:
	po = po + a // 1
	a = a % 1
print(po)


def solve(n):
	denom = [100, 20, 10, 5, 1]
	r = 0
	for d in denom:
		r += n // d
		n %= d
	return r
n = int(input())
print(solve(n))


n = int(input())
a = n // 100
n = n - 100 * a
b = n // 20
n = n - 20 * b
c = n // 10
n = n - 10 * c
d = n // 5
n = n - 5 * d
if n > 0:
	print(a + b + c + d + n)
else:
	print(a + b + c + d)


n = int(input())
bank = [1, 5, 10, 20, 100]
c = 0
for b in bank[::-1]:
	c += n // b
	n = n % b
print(c)


n = int(input())
sum = 0
if n >= 100:
	sum += n // 100
	n = n % 100
if n >= 20:
	sum += n // 20
	n = n % 20
if n >= 10:
	sum += n // 10
	n = n % 10
if n >= 5:
	sum += n // 5
	n = n % 5
if n >= 1:
	sum += n // 1
	n = n % 1
print(sum)


n = int(input())
print(n // 100 + n // 20 % 5 + n // 10 % 2 + n // 5 % 2 + n % 5)


q = 0
x = int(input())
while x != 0:
	if x >= 100:
		l = x // 100
		q += l
		x -= 100 * l
		continue
	elif x >= 20:
		l = x // 20
		q += l
		x -= 20 * l
		continue
	elif x >= 10:
		l = x // 10
		q += l
		x -= 10 * l
		continue
	elif x >= 5:
		l = x // 5
		q += l
		x -= 5 * l
		continue
	else:
		l = x
		q += l
		x -= l
		continue
print(q)


n = int(input())
bills = [1, 5, 10, 20, 100]
bills.sort(reverse=True)
res = 0
numbills = 0
for i in range(len(bills)):
	if not int(n / bills[i]) == 0:
		numbills += int(n / bills[i])
		if n % bills[i] == 0:
			break
		else:
			n = n - bills[i] * int(n / bills[i])
print(numbills)


n = int(input())
l = [100, 20, 10, 5, 1]
i = 0
count = 0
m = n
while m > 0:
	if l[i] <= m:
		count += m // l[i]
		m -= m // l[i] * l[i]
	i += 1
print(count)


x = int(input())
t = 0
while x != 0:
	if x >= 100:
		l = int(x / 100)
		x = x - l * 100
		t = t + l
	elif x >= 20:
		x = x - 20
		t = t + 1
	elif x >= 10:
		x = x - 10
		t = t + 1
	elif x >= 5:
		x = x - 5
		t = t + 1
	elif x >= 1:
		x = x - 1
		t = t + 1
print(t)


from math import *
from copy import *
from string import *
from random import *
from sys import stdin
from sys import maxsize
from operator import *
from itertools import *
from collections import Counter
import math

def bin(l, r, ll, val):
	if l > r:
		return -1
	else:
		mid = (l + r) // 2
		if ll[mid] == val:
			return mid
		elif ll[mid] > val:
			return bin(l, mid - 1, ll, val)
		else:
			return bin(mid + 1, r, ll, val)

def SieveOfEratosthenes(n):
	prime = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	return prime
c = 0
n = int(input())
while n != 0:
	if n >= 100:
		c = c + n // 100
		n = n % 100
	elif n >= 20:
		c = c + n // 20
		n = n % 20
	elif n >= 10:
		c = c + n // 10
		n = n % 10
	elif n >= 5:
		c = c + n // 5
		n = n % 5
	else:
		c = c + n // 1
		n = n % 1
print(c)


n = int(input())
answer = 0
i = 0
b = [100, 20, 10, 5, 1]
while n > 0:
	answer += int(n / b[i])
	n = n % b[i]
	i += 1
print(answer)


c = [1, 5, 10, 20, 100]
n = int(input())
ans = 0
for i in c[::-1]:
	ans += n // i
	n = n % i
print(ans)


n = int(input())
c = int(n / 100)
n = n - c * 100
d = int(n / 20)
n = n - d * 20
e = int(n / 10)
n = n - e * 10
f = int(n / 5)
n = n - f * 5
g = n
print(c + d + e + f + g)


coins = (100, 20, 10, 5, 1)

def findMin3(amount):
	all_coins = 0
	coins_index = 0
	div = coins[coins_index]
	while amount > 0:
		tmp = int(amount / div)
		if tmp > 0:
			all_coins += tmp
			amount -= tmp * div
		else:
			if coins_index >= len(coins):
				break
			coins_index += 1
			div = coins[coins_index]
	return all_coins
n = int(input())
print(findMin3(n))


import sys
n = int(sys.stdin.readline())
nominal = [100, 20, 10, 5, 1]
result = 0
for el in nominal:
	result += n // el
	n %= el
print(result)


n = int(input())
result = 0
while True:
	if n >= 100:
		a = n // 100
		n = n % 100
		result += a
	if n >= 20:
		a = n // 20
		n = n % 20
		result += a
	if n - 10 >= 0:
		n -= 10
		result += 1
	if n - 5 >= 0:
		n -= 5
		result += 1
	if n - 1 >= 0:
		result += n
		n = 0
	if n == 0:
		break
print(result)


(x, i) = (int(input()), 0)
while x > 0:
	if x >= 100:
		i = x // 100
		x %= 100
	elif x >= 20:
		x -= 20
		i += 1
	elif x >= 10:
		x -= 10
		i += 1
	elif x >= 5:
		x -= 5
		i += 1
	elif x >= 1:
		x -= 1
		i += 1
	else:
		print('Error')
print(i)


n = int(input())
coins = [100, 20, 10, 5, 1]
count = 0
for c in coins:
	if n >= c:
		num_bills = n // c
		n -= num_bills * c
		count += num_bills
print(count)


m = int(input())
r = int(m % 100)
b = int(m / 100)
while r > 0:
	if r >= 20:
		r -= 20
	elif r >= 10:
		r -= 10
	elif r >= 5:
		r -= 5
	elif r >= 1:
		r -= 1
	b += 1
print(b)


n = int(input())
ar = [100, 20, 10, 5, 1]
i = 0
cnt = 0
while n:
	if n >= ar[i]:
		s = n // ar[i]
		cnt += s
		n -= s * ar[i]
		i += 1
	else:
		i += 1
print(cnt)


n = int(input())
k = n // 100
n = n % 100
k = k + n // 20
n = n % 20
k = k + n // 10
n = n % 10
k += n // 5
n = n % 5
print(k + n)


Dinero = int(input())
Billetes = 0
for i in (100, 20, 10, 5):
	Billetes = Dinero // i + Billetes
	Dinero = Dinero % i
print(Billetes + Dinero)


a = int(input())
k = 0
if a % 100 == 0:
	a = a / 100
	print(int(a))
else:
	while True:
		if a == 0:
			break
		if a >= 100:
			k = a // 100
			a = a % 100
			continue
		if a < 100:
			if a >= 20:
				a = a - 20
				k = k + 1
				continue
			if a >= 10:
				a = a - 10
				k = k + 1
				continue
			if a >= 5:
				a = a - 5
				k = k + 1
				continue
			if a >= 1:
				a = a - 1
				k = k + 1
				continue
	print(k)


import os, sys
from io import BytesIO, IOBase

def main():
	a = int(input())
	b = 0
	while a > 0:
		if a >= 100:
			b += a // 100
			a = a % 100
		elif a >= 20:
			b += a // 20
			a = a % 20
		elif a >= 10:
			b += a // 10
			a = a % 10
		elif a >= 5:
			b += a // 5
			a = a % 5
		elif a >= 1:
			b += a // 1
			a = a % 1
		else:
			break
	print(b)
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):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		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))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
main()


money = int(input())
bills = 0
while True:
	if money >= 100:
		bills += money // 100
		money = money % 100
		continue
	elif money >= 20:
		bills += money // 20
		money = money % 20
		continue
	elif money >= 10:
		bills += money // 10
		money = money % 10
		continue
	elif money >= 5:
		bills += money // 5
		money = money % 5
		continue
	else:
		bills += money // 1
		money = 0
		break
print(bills)


n = int(input())
l = [100, 20, 10, 5, 1]
b = 0
for i in range(5):
	b += n // l[i]
	n -= l[i] * (n // l[i])
print(b)


a = int(input())
b = a
c = 0
while b != 0:
	if b >= 100:
		b = b - 100
		c += 1
	elif b >= 20 and b < 100:
		b = b - 20
		c += 1
	elif b >= 10 and b < 20:
		b = b - 10
		c += 1
	elif b >= 5 and b < 10:
		b = b - 5
		c += 1
	elif b >= 1 and b < 5:
		b = b - 1
		c += 1
	else:
		print('0')
print(c)


x = eval(input())
sum = x // 100
x = x % 100
sum += x // 20
x = x % 20
sum += x // 10
x = x % 10
sum += x // 5
x = x % 5
sum += x
print(sum)


n = int(input())
x = [100, 20, 10, 5, 1]
s = 0
for i in range(5):
	t = n // x[i]
	n = n - t * x[i]
	s += t
print(s)


mon = int(input())
div = [100, 20, 10, 5, 1]
count = 0
c = 0
i = 0
while mon > 0:
	c = int(mon / div[i])
	count += c
	mon -= div[i] * c
	i += 1
print(count)


class Lottery:

	def __init__(self):
		self.min_count = 0

	def bills(self, num, div):
		if num < div:
			return num
		else:
			self.min_count = self.min_count + num // div
			return num % div
num = int(input())
obj = Lottery()
for i in [100, 20, 10, 5, 1]:
	if num == 0:
		break
	else:
		num = obj.bills(num, i)
print(obj.min_count)


n = int(input())
s = n % 5
n = n - s
for j in [100, 20, 10, 5]:
	s = s + n // j
	n = n - j * (n // j)
print(s)


(a, n) = (int(input()), 0)
n = a // 100
a -= 100 * (a // 100)
n += a // 20
a -= 20 * (a // 20)
n += a // 10
a -= 10 * (a // 10)
n += a // 5
a -= 5 * (a // 5)
print(n + a)


from sys import stdin
inp = stdin.readline
n = int(inp().strip())
denominations = [100, 20, 10, 5, 1]
ans = 0
for note in denominations:
	ans += n // note
	n = n % note
print(ans)


n = int(input())
k = 0
for i in [100, 20, 10, 5]:
	k += n // i
	n = n % i
print(k + n)


t = int(input())
d_100 = t // 100
d_20 = t % 100 // 20
d_10 = t % 100 % 20 // 10
d_5 = t % 100 % 20 % 10 // 5
d_1 = t % 100 % 20 % 10 % 5 // 1
print(d_100 + d_20 + d_10 + d_5 + d_1)


values = (100, 20, 10, 5, 1)
nbValues = 0
n = int(input())
while n > 0:
	for v in values:
		nbValues += int(n / v)
		n %= v
print(nbValues)


money = int(input())
notes = ['100', '20', '10', '5', '1']
x = 0
hmnotes = 0
while int(money) < int(notes[x]):
	x += 1
for n in range(5 - x):
	a = int(money / int(notes[x]))
	hmnotes = hmnotes + a
	money = money - int(notes[x]) * a
	x += 1
print(hmnotes)


money = int(input())
s = 0
nominal = [100, 20, 10, 5, 1]
for nom in nominal:
	s += money // nom
	money = money % nom
print(s)


def solve():
	n = int(input())
	denominations = [100, 20, 10, 5, 1]
	ans = 0
	for denomination in denominations:
		ans += n // denomination
		n %= denomination
	print(ans)
solve()


num = int(input())
bills = [100, 20, 10, 5, 1]
total_bills = sum([num % bills[bills.index(bill) - 1] // bill if bills.index(bill) > 0 else num // bill for bill in bills])
print(total_bills)


num = int(input())
notes = 0
notes += num // 100
num = num % 100
notes += num // 20
num = num % 20
notes += num // 10
num = num % 10
notes += num // 5
num = num % 5
notes += num
print(notes)


from functools import reduce
ls = [1, 5, 10, 20, 100]

def countBill(tup, curr):
	(r, s) = tup
	return (r % curr, s + r // curr)

def solve(n):
	(r, res) = reduce(countBill, ls[::-1], (n, 0))
	return res
n = int(input())
print(solve(n))


n = int(input())
n1 = n // 100
n = n % 100
n2 = n // 20
n = n % 20
n3 = n // 10
n = n % 10
n4 = n // 5
n = n % 5
n5 = n // 1
print(n1 + n2 + n3 + n4 + n5)


import math
total = int(input())
hundreds = math.floor(total / 100)
total -= hundreds * 100
twenties = math.floor(total / 20)
total -= twenties * 20
tens = math.floor(total / 10)
total -= tens * 10
fives = math.floor(total / 5)
total -= fives * 5
ones = total
minimum = hundreds + twenties + tens + fives + ones
print(minimum)


deno = 0
amount = int(input())
deno += amount // 100
amount %= 100
if amount != 0:
	deno += amount // 20
	amount %= 20
	if amount != 0:
		deno += amount // 10
		amount %= 10
		if amount != 0:
			deno += amount // 5
			amount %= 5
			if amount != 0:
				deno += amount // 1
print(deno)


a = str(input())
b = sorted([1, 5, 10, 20, 100], reverse=True)
c = len(a)
w = int()
for x in b:
	if int(a) / x != int():
		w = w + int(int(a) / x)
		a = int(a) % x
print(int(w))


import math
n = int(input())
num = 0
c100 = n // 100
left1 = n - c100 * 100
c20 = left1 // 20
left2 = left1 - c20 * 20
c10 = left2 // 10
left3 = left2 - c10 * 10
c5 = left3 // 5
left4 = left3 - c5 * 5
c1 = math.ceil(left4 / 1)
num = c100 + c20 + c10 + c5 + c1
print(num)


a = [100, 20, 10, 5, 1]
k = int(input())
res = 0
for i in a:
	if k == 0:
		break
	elif i <= k:
		res += k // i
		k %= i
print(res)


n = int(input())
r = 0
while n != 0:
	if n >= 100:
		r += n // 100
		n = n % 100
	if n >= 20:
		r += n // 20
		n = n % 20
	if n >= 10:
		r += n // 10
		n = n % 10
	if n >= 5:
		r += n // 5
		n = n % 5
	if n >= 1:
		r += n
		n = n - n
print(r)


denom = [100, 20, 10, 5, 1]
n = int(input())
bills = 0
while n != 0:
	for i in denom:
		if n >= i:
			x = n // i
			n -= x * i
			bills += x
			break
print(bills)


n = int(input())
sn = str(n)
hun = 0
twen = 0
five = 0
one = 0
hun = n // 100
if len(sn) > 1 and int(sn[-2]) % 2 == 0:
	twen = n % 100 // 20
elif len(sn) > 1:
	twen = n % 100 // 20 + 1
if n % 10 >= 5:
	five = 1
	one = n % 10 - 5
else:
	five = 0
	one = n % 10
print(hun + twen + five + one)


n = int(input())
val1 = (n - n % 100) // 100
n = n % 100
val2 = (n - n % 20) // 20
n = n % 20
val3 = (n - n % 10) // 10
n = n % 10
val4 = (n - n % 5) // 5
n = n % 5
val5 = n
print(val2 + val1 + val3 + val4 + val5)


from sys import stdin, stdout
t = int(stdin.readline())
c = 0
if t >= 100:
	c += int(t / 100)
	t = t % 100
if t >= 20:
	c += int(t / 20)
	t = t % 20
if t >= 10:
	c += int(t / 10)
	t = t % 10
if t >= 5:
	c += int(t / 5)
	t = t % 5
c += t
print(c)


m = int(input())
num = 0
num = num + m // 100
m = m % 100
num = num + m // 20
m = m % 20
num = num + m // 10
m = m % 10
num = num + m // 5 + m % 5
print(num)


import sys
b = [1, 5, 10, 20, 100]
for i in sys.stdin:
	(n, c) = (0, int(i.strip('\n')))
	for j in b[::-1]:
		n += c // j
		c %= j
	print(n)


cash = int(input())
m = 0
if int(cash / 100):
	m += int(cash / 100)
	cash = int(cash % 100)
if int(cash / 20):
	m += int(cash / 20)
	cash = int(cash % 20)
if int(cash / 10):
	m += int(cash / 10)
	cash = int(cash % 10)
if int(cash / 5):
	m += int(cash / 5)
	cash = int(cash % 5)
if int(cash / 1):
	m += int(cash / 1)
	cash = int(cash % 1)
print(m)


n = int(input(''))
z = 0
z = z + n // 100
n = n % 100
z = z + n // 20
n = n % 20
z = z + n // 10
n = n % 10
z = z + n // 5
n = n % 5
z = z + n // 1
n = n % 1
print(int(z))


t = int(input())
a_100 = t // 100
a_20 = t % 100 // 20
a_10 = t % 100 % 20 // 10
a_5 = t % 100 % 20 % 10 // 5
a_1 = t % 100 % 20 % 10 % 5 // 1
print(a_100 + a_20 + a_10 + a_5 + a_1)


n = int(input())
l = [100, 20, 10, 5, 1]
res = 0
for i in l:
	res += n // i
	n %= i
print(res)


n = int(input())
s100 = int(n / 100)
a100 = n % 100
s20 = int(a100 / 20)
a100 = a100 % 20
s10 = int(a100 / 10)
a100 = a100 % 10
s5 = int(a100 / 5)
a100 = a100 % 5
s1 = int(a100 / 1)
print(s100 + s20 + s10 + s5 + s1)


n = int(input())
count = 0
while n > 0:
	if n % 100 == 0:
		count = int(n / 100)
		break
	if n / 100 >= 1:
		count += 1
		n = n - 100
		continue
	if n / 20 >= 1:
		count += 1
		n = n - 20
		continue
	if n / 10 >= 1:
		count += 1
		n = n - 10
		continue
	if n / 5 >= 1:
		count += 1
		n = n - 5
		continue
	if n / 1 >= 1:
		count += 1
		n = n - 1
		continue
print(count)


a = int(input())
print(a // 100 + a % 100 // 20 + a % 100 % 20 // 10 + a % 100 % 20 % 10 // 5 + a % 100 % 20 % 10 % 5)


n = int(input())
k = n // 100
n = n % 100
if n >= 20:
	k = k + n // 20
	n = n % 20
if n >= 10:
	k = k + n // 10
	n = n % 10
if n >= 5:
	k = k + n // 5
	n = n % 5
if n >= 1:
	n = n / 1
	k = k + n // 1
print(int(k))


n = int(input())
cnt = 0
cnt += n // 100
n %= 100
cnt += n // 20
n %= 20
cnt += n // 10
n %= 10
cnt += n // 5
n %= 5
cnt += n
print(cnt)


n = int(input())
a = [100, 20, 10, 5, 1]
ans = 0
i = 0
while n != 0:
	if n >= a[i]:
		ans += n // a[i]
		n = n % a[i]
	i += 1
print(ans)


from math import floor
import sys
n = int(sys.stdin.readline())
k = 0
while n > 0:
	p = n / 100
	if p >= 1:
		a = floor(p)
		k += a
		n -= 100 * a
	p = n / 20
	if p >= 1:
		a = floor(p)
		k += a
		n -= 20 * a
	p = n / 10
	if p >= 1:
		a = floor(p)
		k += a
		n -= 10 * a
	p = n / 5
	if p >= 1:
		a = floor(p)
		k += a
		n -= 5 * a
	p = n / 1
	if p >= 1:
		a = floor(p)
		k += a
		n -= 1 * a
sys.stdout.write(str(k))
sys.stdout.flush()


import math
a = int(input())
bills = 0
if a >= 100:
	bills += math.floor(a / 100)
	a -= bills * 100
if a >= 20:
	bills += math.floor(a / 20)
	n = math.floor(a / 20)
	a -= n * 20
if a >= 10:
	bills += math.floor(a / 10)
	n = math.floor(a / 10)
	a -= n * 10
if a >= 5:
	bills += math.floor(a / 5)
	n = math.floor(a / 5)
	a -= n * 5
if a >= 1:
	bills += math.floor(a / 1)
print(bills)


n = int(input())
ans = 0
ans += n // 100
n %= 100
ans += n // 20
n %= 20
ans += n // 10
n %= 10
ans += n // 5
n %= 5
ans += n // 1
print(ans)


n = int(input())
denom = [100, 20, 10, 5, 1]
bills = 0
for i in denom:
	if n // i > 0:
		bills += n // i
		n -= n // i * i
print(bills)


def main():
	n = int(input())
	c = 0
	c += n // 100
	n = n % 100
	c += n // 20
	n = n % 20
	c += n // 10
	n = n % 10
	c += n // 5
	n = n % 5
	print(c + n)
	return 0
main()


n = int(input())
bills = n // 100
n = n - n // 100 * 100
bills += n // 20
n = n - n // 20 * 20
bills += n // 10
n = n - n // 10 * 10
bills += n // 5
n = n - n // 5 * 5
bills += n
print(bills)


def change(d, n, m):
	if m == 0:
		return 0
	elif n < 0:
		return 10008000
	else:
		return min(change(d, n - 1, m), change(d, n - 1, m % d[n]) + m // d[n])
d = [1, 5, 10, 20, 100]
n = len(d)
m = int(input())
print(change(d, n - 1, m))


m = int(input())
x = [100, 20, 10, 5, 1]
bills = 0
for i in x:
	bills += m // i
	m = m % i
print(bills)


def r(t=int):
	return list(map(t, input().split()))

def ri(t=int):
	return t(input())

def cd(it):
	ret_val = dict()
	for v in it:
		ret_val[v] = ret_val.get(v, 0) + 1
	return ret_val
a = ri()
c = 0
for k in [100, 20, 10, 5, 1]:
	c += a // k
	a %= k
print(c)


n = int(input())
s = 0
s += n // 100
n -= 100 * (n // 100)
s += n // 20
n -= 20 * (n // 20)
s += n // 10
n -= 10 * (n // 10)
s += n // 5
n -= 5 * (n // 5)
s += n // 1
n -= 1 * (n // 1)
print(s)


n = int(input())
l = [100, 20, 10, 5, 1]
c = 0
while n > 0:
	for i in range(len(l)):
		if n // l[i] > 0:
			c += n // l[i]
			z = n % l[i]
			break
	n = z
print(c)


def lottery(n):
	res = 0
	i = 0
	liste_billets = [100, 20, 10, 5, 1]
	while n > 0 and i < 5:
		tmp = n // liste_billets[i]
		n -= tmp * liste_billets[i]
		res += tmp
		i += 1
	return res
n = int(input())
print('{}'.format(lottery(n)))


n = int(input())
su = 0
su += int(n / 100)
n = n % 100
su += int(n / 20)
n = n % 20
su += int(n / 10)
n = n % 10
su += int(n / 5)
n = n % 5
su += int(n / 1)
n = n % 1
print(su)


n = int(input())
c = 0
while n != 0:
	if n >= 100:
		c += n // 100
		n = n % 100
	elif n >= 20:
		c += n // 20
		n = n % 20
	elif n >= 10:
		c += n // 10
		n = n % 10
	elif n >= 5:
		c += n // 5
		n = n % 5
	else:
		c += n
		n = 0
print(c)


from sys import stdin, stdout
from math import gcd, sqrt, floor, ceil
input = stdin.readline
print = stdout.write

def list_inp(x):
	return list(map(x, input().split()))

def map_inp(x):
	return map(x, input().split())

def lcm(a, b):
	return a * b / gcd(a, b)
n = int(input())
bills = [100, 20, 10, 5, 1]
cnt = 0
for i in bills:
	if n <= 0:
		break
	if n >= i:
		cnt += n // i
		n = n % i
print(str(cnt))


s = int(input())
ni = s // 100
i = s % 100 // 20
uni = s % 100 % 20 // 10
fni = s % 100 % 20 % 10 // 5
rni = s % 100 % 20 % 10 % 5 // 1
print(ni + i + uni + fni + rni)


n = int(input())
counter = 0
if n / 100 >= 1:
	counter += int(n / 100)
	n = n % 100
if n / 20 >= 1:
	counter += int(n / 20)
	n = n % 20
if n / 10 >= 1:
	counter += int(n / 10)
	n = n % 10
if n / 5 >= 1:
	counter += int(n / 5)
	n = n % 5
if n / 1 >= 1:
	counter += int(n / 1)
	n = n % 1
print(int(counter))


n = int(input())
c1 = 0
c2 = 0
c3 = 0
c4 = 0
c5 = 0
while n != 0:
	if n >= 100:
		c1 = c1 + n // 100
		n = n % 100
	elif n >= 20 and n < 100:
		n = n - 20
		c2 = c2 + 1
	elif n >= 10 and n < 20:
		n = n - 10
		c3 = c3 + 1
	elif n >= 5 and n < 10:
		n = n - 5
		c4 = c4 + 1
	elif n >= 1 and n < 5:
		n = n - 1
		c5 = c5 + 1
print(c1 + c2 + c3 + c4 + c5)


n = int(input())
bills = [1, 5, 10, 20, 100]
answer = 0
for b in bills[::-1]:
	answer += n // b
	n -= n // b * b
print(answer)


n = int(input())
denoms = [100, 20, 10, 5, 1]
out = 0
for i in range(len(denoms)):
	out += n // denoms[i]
	n = n % denoms[i]
print(out)


denom = [100, 20, 10, 5, 1]

def f(n):
	count = 0
	for d in denom:
		count += n // d
		n = n % d
	return count
assert f(125) == 3
assert f(43) == 5
assert f(1000000000) == 10000000
n = int(input())
count = f(n)
print(count)


n = int(input())
count = 0
div = 0
while n > 0:
	if n >= 100:
		div = n // 100
		count += div
		n -= 100 * div
	elif n >= 20:
		div = n // 20
		count += div
		n -= 20 * div
	elif n >= 10:
		div = n // 10
		count += div
		n -= 10 * div
	elif n >= 5:
		div = n // 5
		count += div
		n -= 5 * div
	else:
		div = n // 1
		count += div
		n -= 1 * div
print(count)


import sys
input = sys.stdin.readline
import time

def inp():
	return int(input())

def inlt():
	return list(map(int, input().split()))

def insr():
	s = input()
	return list(s[:len(s) - 1])

def invr():
	return map(int, input().split())
n = inp()
start = time.process_time()
bills = [100, 20, 10, 5, 1]
nb_bills = 0
for bill in bills:
	count = n // bill
	n -= count * bill
	nb_bills += count
print(nb_bills)


denomi = [100, 20, 10, 5, 1]
N = int(input())
sum = 0
for i in range(0, 5):
	sum += N // denomi[i]
	N %= denomi[i]
print(sum)


dollars = int(input())
count = int(0)
nominals = [int(100), int(20), int(10), int(5), int(1)]
for nominal in nominals:
	count += int(dollars / nominal)
	dollars = dollars % nominal
print(count)


Total_balance = int(input())
m_bills = 0
Remainder = 0
m_bills = Total_balance // 100
Remainder = Total_balance % 100
m_bills += Remainder // 20
Remainder %= 20
m_bills += Remainder // 10
Remainder %= 10
m_bills += Remainder // 5
Remainder %= 5
m_bills += Remainder / 1
print(int(m_bills))


n = int(input())
z = n
nt = 0
m = 0
l = [100, 20, 10, 5, 1]
for i in l:
	nt = nt + n // i
	m = m + n // i * i
	if m == z:
		break
	else:
		n = n % i
print(nt)


a = [100, 20, 10, 5, 1]
n = int(input())
sum = 0
for x in a:
	sum += n // x
	n %= x
print(sum)


import math
import sys

def inp():
	return int(input())

def inlt():
	return list(map(int, input().split()))

def insr():
	s = input()
	return list(s[:len(s) - 1])

def invr():
	return map(int, input().split())
n = int(input())
bills = [100, 20, 10, 5, 1]
count = 0
for bill in bills:
	count += n // bill
	n = n % bill
print(count)


m = int(input())
n = 4
d = [1, 5, 10, 20]
ans = 0
if m >= 100:
	ans = ans + m // 100
	m = m % 100

def changeTabulation(d, n, m):
	table = [[-1 for x in range(m + 1)] for y in range(n + 1)]
	for i in range(n + 1):
		table[i][0] = 0
	for j in range(1, m + 1):
		table[0][j] = 10008000
	for i in range(1, n + 1):
		for j in range(1, m + 1):
			table[i][j] = min(table[i - 1][j], table[i - 1][j % d[i - 1]] + j // d[i - 1])
	return table[n][m]

def changeMemoization(d, n, m, table):
	if table[n][m] == None:
		table[n][m] = min(changeMemoization(d, n - 1, m, table), changeMemoization(d, n - 1, m % d[n - 1], table) + m // d[n - 1])
	return table[n][m]
table = [[None for x in range(m + 1)] for y in range(n + 1)]
for i in range(n + 1):
	table[i][0] = 0
for j in range(1, m + 1):
	table[0][j] = 10008000
print(ans + changeMemoization(d, n, m, table))


n = int(input())
dp = [99] * 101
dp[0] = 0
for i in range(1, 101):
	dp[i] = min(dp[i - 1], dp[i - 5], dp[i - 10], dp[i - 20], dp[i - 100]) + 1
print(dp[n % 100] + n // 100)


t = int(input())
x100 = t // 100
t %= 100
x20 = t // 20
t %= 20
x10 = t // 10
t %= 10
x5 = t // 5
t %= 5
x1 = t // 1
print(x1 + x5 + x10 + x20 + x100)


n = int(input())
res = 0
while n > 0:
	if n >= 100:
		sub = n // 100
		n -= 100 * sub
	elif n >= 20:
		sub = n // 20
		n -= 20 * sub
	elif n >= 10:
		sub = n // 10
		n -= 10 * sub
	elif n >= 5:
		sub = n // 5
		n -= 5 * sub
	else:
		sub = n // 1
		n -= sub
	res += sub
print(res)


bills = [1, 5, 10, 20, 100]
n = int(input())
totalBills = 0
for i in reversed(bills):
	if n >= i:
		totalBills += n // i
	n %= i
print(totalBills)


n = int(input())
a = [1, 5, 10, 20, 100]
col = 0
for i in range(4, -1, -1):
	if n >= a[i]:
		col += n // a[i]
		n = n - n // a[i] * a[i]
print(col)


N = int(input())
DENOMINATIONS = [100, 20, 10, 5, 1]
count = 0
for denom in DENOMINATIONS:
	count += N // denom
	N %= denom
	if N == 0:
		break
print(count)


co = 0
n = int(input())
while n != 0:
	if n >= 100:
		k = n // 100
		co += k
		n -= 100 * k
	elif n >= 20:
		k = n // 20
		co += k
		n -= 20 * k
	elif n >= 10:
		k = n // 10
		co += k
		n -= 10 * k
	elif n >= 5:
		k = n // 5
		co += k
		n -= 5 * k
	else:
		k = n // 1
		co += k
		n -= 1 * k
print(co)


total = 0
x = int(input())
total += int(x / 100)
x -= total * 100
total += int(x / 20)
x -= int(x / 20) * 20
total += int(x / 10)
x -= int(x / 10) * 10
total += int(x / 5)
x -= int(x / 5) * 5
total += int(x)
print(total)


money = int(input())
count = 0
while money != 0:
	if money / 100 > 0:
		count += int(money / 100)
		money %= 100
	if money / 20 > 0:
		count += int(money / 20)
		money %= 20
	if money / 10 > 0:
		count += int(money / 10)
		money %= 10
	if money / 5 > 0:
		count += int(money / 5)
		money %= 5
	if money > 0:
		count += money
		money = 0
print(count)


n = int(input())
total = 0
array = [100, 20, 10, 5, 1]
for i in array:
	if n <= 0:
		break
	total += n // i
	n -= i * (n // i)
print(total)


def lot(val):
	b = 0
	if val >= 100:
		b += val // 100
		val = val % 100
	if val < 100 and val >= 20:
		b += val // 20
		val = val % 20
	if val >= 10 and val < 20:
		b += val // 10
		val = val % 10
	if val >= 5 and val < 10:
		b += val // 5
		val = val % 5
	if val < 5:
		b += val
	return b
i = int(input())
print(lot(i))


n = int(input())
count = 0
d = [1, 5, 10, 20, 100]
k = len(d)
i = k - 1
while i >= 0:
	while n >= d[i]:
		n -= d[i]
		count = count + 1
	i = i - 1
print(count)


n = int(input())
ans = 0
for el in [100, 20, 10, 5, 1]:
	k = n // el
	ans += k
	n -= el * k
print(ans)


from sys import stdin, exit
n = int(stdin.readline())
c = 0
for cur in [100, 20, 10, 5, 1]:
	t = n // cur
	n -= t * cur
	c += t
print(c)


i = int(input())
hundred = int(i / 100)
twenty = int(i % 100 / 20)
ten = int(i % 20 / 10)
five = int(i % 10 / 5)
print(hundred + twenty + ten + five + i % 5)


n = int(input())
answer = 0
for bill in (100, 20, 10, 5, 1):
	answer += n // bill
	n %= bill
print(answer)


import array
n = int(input())
sum = 0
a = array.array('i', [100, 20, 10, 5, 1])
for i in range(0, 5):
	sum += int(n / a[i])
	n = n % a[i]
print(sum)


num = input()
num = int(num)
sum = int(0)
if num >= 100:
	sum += int(num / 100)
num = num % 100
if num >= 20:
	sum += int(num / 20)
	num = num % 20
if num >= 10:
	sum += int(num / 10)
	num = num % 10
if num >= 5:
	sum += int(num / 5)
	num = num % 5
print(sum + num)


n = int(input())
sum1 = 0
sum1 = sum1 + int(n / 100)
n1 = n % 100
sum1 = sum1 + int(n1 / 20)
n2 = n1 % 20
sum1 = sum1 + int(n2 / 10)
n3 = n2 % 10
sum1 = sum1 + int(n3 / 5)
n4 = n3 % 5
sum1 = sum1 + n4
print(sum1)


T = int(input())
sum = 0
sum += T // 100
T = T % 100
sum += T // 20
T = T % 20
sum += T // 10
T = T % 10
sum += T // 5
T = T % 5
print(sum + T)


import sys
l = int(input())
compteur = 0
while l != 0:
	if l > 100:
		compteur += l // 100
		l = l % 100
	if l >= 10:
		if l // 10 - 2 >= 0:
			compteur += 1
			l -= 20
		elif l // 10 - 1 >= 0:
			compteur += 1
			l -= 10
	elif l > 0:
		if l - 5 >= 0:
			compteur += 1
			l -= 5
		elif l - 1 >= 0:
			compteur += 1
			l -= 1
	elif l == 0:
		break
print(compteur)


numero = int(input())
out = 0
while numero // 100000 > 0:
	numero = numero - 100000
	out = out + 1000
while numero // 100 > 0:
	numero = numero - 100
	out = out + 1
while numero // 20 > 0:
	numero = numero - 20
	out = out + 1
while numero // 10 > 0:
	numero = numero - 10
	out = out + 1
while numero // 5 > 0:
	numero = numero - 5
	out = out + 1
while numero // 1 > 0:
	numero = numero - 1
	out = out + 1
print(out)


def get_minimum_bills():
	amount_to_withdraw = int(input())
	bills = [1, 5, 10, 20, 100]
	count = 0
	while amount_to_withdraw:
		bills = [x for x in bills if x <= amount_to_withdraw]
		temp = amount_to_withdraw // max(bills)
		count = count + temp
		amount_to_withdraw = amount_to_withdraw - temp * max(bills)
	return count
print(get_minimum_bills())


a = int(input())
k = 0
k += a // 100
a -= a // 100 * 100
k += a // 20
a -= a // 20 * 20
k += a // 10
a -= a // 10 * 10
k += a // 5
a -= a // 5 * 5
k += a
print(k)


R = lambda : map(int, input().split())
n = int(input())
arr = [100, 20, 10, 5, 1]
ans = 0
for i in arr:
	ans += n // i
	n = n % i
print(ans)


num = int(input())
ans = 0
ans += num // 100
num -= num // 100 * 100
ans += num // 20
num -= num // 20 * 20
ans += num // 10
num -= num // 10 * 10
ans += num // 5
num -= num // 5 * 5
ans += num
print(ans)


l = int(input())
count = 0
if l >= 100:
	minus100 = l // 100
	count += minus100
	l -= minus100 * 100
if l >= 20:
	minus20 = l // 20
	count += minus20
	l -= minus20 * 20
if l >= 10:
	minus10 = l // 10
	count += minus10
	l -= minus10 * 10
if l >= 5:
	minus5 = l // 5
	count += minus5
	l -= minus5 * 5
if l >= 1:
	minus1 = l // 1
	count += minus1
	l -= minus1
print(count)


n = int(input())
count = 0
while n > 0:
	if n // 100 != 0:
		count += n // 100
		n = n % 100
	elif n // 20 != 0 and n < 100:
		count += n // 20
		n = n % 20
	elif n // 10 != 0 and n < 20:
		count += n // 10
		n = n % 10
	elif n // 5 != 0 and n < 10:
		count += n // 5
		n = n % 5
	elif 1 <= n < 5:
		n -= 1
		count += 1
print(count)


n = int(input())
total = 0
total += n // 100
n -= 100 * (n // 100)
total += n // 20
n -= 20 * (n // 20)
total += n // 10
n -= 10 * (n // 10)
total += n // 5
n -= 5 * (n // 5)
total += n
print(total)


SS = int(input())
billes = int(0)
while SS > 0:
	if SS >= 100:
		a = SS // 100
		SS -= a * 100
		billes += a
	elif SS >= 20:
		a = SS // 20
		SS -= a * 20
		billes += a
	elif SS >= 10:
		a = SS // 10
		SS -= 10 * a
		billes += a
	elif SS >= 5:
		a = SS // 5
		SS -= 5 * a
		billes += a
	elif SS >= 1:
		a = SS // 1
		SS -= a
		billes += a
print(billes)


from sys import stdin
money = int(stdin.readline())
number_of_bills = 0
while money > 0:
	if money >= 5:
		if money >= 10:
			if money >= 20:
				if money >= 100:
					bills = int(money / 100)
					money = money - 100 * bills
					number_of_bills += bills
				else:
					bills = int(money / 20)
					money = money - 20 * bills
					number_of_bills += bills
			else:
				money -= 10
				number_of_bills += 1
		else:
			money -= 5
			number_of_bills += 1
	else:
		number_of_bills += money
		money = 0
print(number_of_bills)


a = int(input())
n = 0
k = a // 100
n += k
a -= k * 100
j = a // 20
n += j
a -= j * 20
r = a // 10
n += r
a -= r * 10
m = a // 5
n += m
a -= m * 5
print(n + a)


s = int(input())
numPull = s // 100
s = s % 100
numPull = numPull + s // 20
s = s % 20
numPull = numPull + s // 10
s = s % 10
numPull = numPull + s // 5
s = s % 5
numPull = numPull + s
print(numPull)


n = int(input())
res = 0
a1 = n // 100
res += a1
n -= a1 * 100
a2 = n // 20
res += a2
n -= a2 * 20
a3 = n // 10
res += a3
n -= a3 * 10
a4 = n // 5
res += a4
n -= a4 * 5
res += n
print(res)


amount = int(input())
n = 0
for i in [100, 20, 10, 5, 1]:
	while amount:
		n += amount // i
		amount = amount % i
		break
print(n)


n = int(input())
bills = 0

def count(n, b):
	if n >= 100:
		b += n // 100
		n = n % 100
		return count(n, b)
	elif n >= 20:
		b += n // 20
		n = n % 20
		return count(n, b)
	elif n >= 10:
		b += n // 10
		n = n % 10
		return count(n, b)
	elif n >= 5:
		b += n // 5
		n = n % 5
		return count(n, b)
	elif n >= 1:
		b += n
		n = 0
		return count(n, b)
	else:
		return b
print(count(n, bills))


n = int(input())
nofbills = 0
dollars = [100, 20, 10, 5, 1]
for d in dollars:
	if n == 0:
		break
	if n >= d:
		mod = n % d
		nofbills += (n - mod) // d
		n = mod
print(nofbills)


cash = int(input())
num_bills = 0
while cash != 0:
	if cash >= 100:
		num_bills += 1
		cash = cash - 100
	if cash < 100 and cash >= 20:
		num_bills += 1
		cash = cash - 20
	if cash < 20 and cash >= 10:
		num_bills += 1
		cash = cash - 10
	if cash < 10 and cash >= 5:
		num_bills += 1
		cash = cash - 5
	if cash < 5 and cash >= 1:
		num_bills += 1
		cash = cash - 1
print(num_bills)


import time
n = int(input())
start = time.time()
ans = n // 100
n = n % 100
ans += n // 20
n = n % 20
ans += n // 10
n = n % 10
ans += n // 5
n = n % 5
ans += n
print(ans)
finish = time.time()


def withdraw(n):
	lis = [100, 20, 10, 5, 1]
	cash_count = 0
	if n != 0:
		for i in lis:
			if n >= i:
				cash_count += n // i
				n %= i
			elif n < 5:
				cash_count += n
				n = 0
	return cash_count
n = int(input().strip())
print(withdraw(n))


n = int(input())
b = 0
for i in [100, 20, 10, 5, 1]:
	if n >= i:
		b += n // i
		n %= i
print(b)


n = int(input())
(coins, i, nominals) = (0, 0, [100, 20, 10, 5, 1])
while n > 0:
	while n >= nominals[i]:
		coins += 1
		n -= nominals[i]
	i += 1
print(coins)


from sys import stdin
import math
a = stdin.readline()
a = int(a)
count = 0
b = math.floor(a / 100)
count = count + b
a = a - 100 * b
c = math.floor(a / 20)
count = count + c
a = a - 20 * c
d = math.floor(a / 10)
count = count + d
a = a - 10 * d
e = math.floor(a / 5)
count = count + e
a = a - 5 * e
count = count + a
print(count)


n = int(input())
bills = 0
dollars = [100, 20, 10, 5, 1]
for d in dollars:
	bills += n // d
	n %= d
	if n == 0:
		break
print(bills)


x = int(input())
notes = 0
l = [100, 20, 10, 5, 1]
for i in range(len(l)):
	notes += x // l[i]
	x %= l[i]
print(notes)


n = int(input())
b = 0
m = False

def main():
	global b
	q = n // 100
	w = (n - q * 100) // 20
	e = (n - q * 100 - w * 20) // 10
	r = (n - q * 100 - w * 20 - e * 10) // 5
	t = n - q * 100 - w * 20 - e * 10 - r * 5
	b = q + w + e + r + t
	print(b)
main()


n = int(input())
l = [100, 20, 10, 5, 1]
s = 0
for k in l:
	d = int(n / k)
	n -= d * k
	s += d
print(s)


n = int(input())
ans = n // 100
n = n % 100
ans += n // 20
n = n % 20
ans += n // 10
n = n % 10
ans += n // 5
n = n % 5
ans += n
print(ans)


n = int(input())
count = 0
if n >= 100:
	rem = n // 100
	n = n - 100 * rem
	count += rem
if n >= 20:
	rem = n // 20
	n = n - 20 * rem
	count += rem
if n >= 10:
	rem = n // 10
	n = n - 10 * rem
	count += rem
if n >= 5:
	rem = n // 5
	n = n - rem * 5
	count += rem
if n >= 1:
	rem = n // 1
	count += rem
print(count)


n = int(input())
l = 0
l += n // 100
n = n % 100
l += n // 20
n = n % 20
l += n // 10
n = n % 10
l += n // 5
n = n % 5
l += n // 1
n = n % 1
print(l)


n = int(input())
c = n // 100
n = n % 100
c += n // 20
n = n % 20
c += n // 10
n = n % 10
c += n // 5
n = n % 5
c += n // 1
print(c)


money = int(input())
t = 0
oh = int(money / 100)
money = oh * 100 - money
money = abs(money)
tw = int(money / 20)
money = tw * 20 - money
money = abs(money)
ten = int(money / 10)
money = ten * 10 - money
money = abs(money)
five = int(money / 5)
money = five * 5 - money
money = abs(money)
one = int(money / 1)
money = one * 1 - money
money = abs(money)
t += oh + tw + ten + five + one
print(t)


n = int(input())
b = 0
if n >= 100:
	b += n // 100
	n = n % 100
if n >= 20 and n < 100:
	b += n // 20
	n = n % 20
if n >= 10 and n < 20:
	b += n // 10
	n = n % 10
if n >= 5 and n < 10:
	b += n // 5
	n = n % 5
if n >= 1 and n < 5:
	b += n // 1
	n = n % 1
print(b)


from sys import stdin, stdout

def getMinimumDollarBills(n: int) -> int:
	dollarBills = [100, 20, 10, 5, 1]
	totalBills = 0
	for dollar in dollarBills:
		while n != 0 and dollar <= n:
			n -= dollar
			totalBills += 1
		if n == 0:
			break
	return totalBills

def main():
	n = int(stdin.readline())
	stdout.write(f'{getMinimumDollarBills(n)}\n')
main()


n = int(input())
c = 0
notes = [100, 20, 10, 5, 1]
for note in notes:
	if n > 0:
		c += n // note
		n = n % note
	else:
		break
print(c)


output = 0
bills = [1, 5, 10, 20, 100]
n = int(input())
while len(bills):
	if n >= bills[len(bills) - 1]:
		output += n // bills[len(bills) - 1]
		n = n % bills[len(bills) - 1]
		bills.pop()
	else:
		bills.pop()
print(output)


n = int(input())
hun = n // 100
n -= hun * 100
twe = n // 20
n -= twe * 20
ten = n // 10
n -= ten * 10
five = n // 5
n -= five * 5
one = n - 0
print(hun + twe + ten + five + one)


n = int(input())
bills = 0
for d in (100, 20, 10, 5, 1):
	b = n // d
	n -= d * b
	bills += b
	if not n:
		break
print(bills)


def main():
	coins = [100, 20, 10, 5, 1]
	n = int(input())
	total = 0
	for c in coins:
		while n >= c:
			total += n // c
			n = n % c
	print(total)
main()


a = int(input())
coin = [100, 20, 10, 5, 1]
count = 0
for i in range(5):
	if coin[i] <= a:
		d = a // coin[i]
		count += d
		a -= d * coin[i]
print(count)


cash = int(input())
ans = 0
while cash != 0:
	if cash >= 100:
		if cash % 100 == 0:
			ans += cash / 100
			cash = 0
			break
		elif cash % 100 != 0:
			ans += int(cash / 100)
			cash -= 100 * int(cash / 100)
	elif cash >= 20:
		if cash / 20 == 1:
			ans += 1
			cash = 0
		elif cash / 20 != 1:
			ans += int(cash / 20)
			cash -= 20 * int(cash / 20)
	elif cash >= 10:
		if cash / 10 == 1:
			ans += 1
			cash = 0
		elif cash / 10 != 1:
			ans += int(cash / 10)
			cash -= 10 * int(cash / 10)
	elif cash >= 5:
		if cash / 5 == 1:
			ans += 1
			cash = 0
		elif cash / 5 != 1:
			ans += int(cash / 5)
			cash -= 5 * int(cash / 5)
	else:
		ans += cash
		cash = 0
print(int(ans))


n = int(input())
e = 0
a = 0
b = 0
c = 0
d = 0
while n > 0:
	if n >= 100:
		a = n // 100
		n = n - a * 100
	elif n >= 20:
		b = n // 20
		n = n - b * 20
	elif n >= 10:
		c = n // 10
		n = n - c * 10
	elif n >= 5:
		d = n // 5
		n = n - d * 5
	elif n >= 1:
		while n != 0:
			n = n - 1
			e = e + 1
a = a + b + c + d + e
print(a)


x = int(input())
y = 0
bills = [100, 20, 10, 5, 1]
for bill in bills:
	q = x // bill
	x -= q * bill
	y += q
print(y)


a = int(input())
b_100 = a // 100
b_20 = a % 100 // 20
b_10 = a % 100 % 20 // 10
b_5 = a % 100 % 20 % 10 // 5
b_1 = a % 100 % 20 % 10 % 5
print(b_100 + b_20 + b_10 + b_5 + b_1)


from sys import stdin
N = int(stdin.readline())
ans = 0
while N > 0:
	if N >= 100:
		ans += N // 100
		N -= N // 100 * 100
	elif N >= 20:
		ans += N // 20
		N -= N // 20 * 20
	elif N >= 10:
		ans += N // 10
		N -= N // 10 * 10
	elif N >= 5:
		ans += N // 5
		N -= N // 5 * 5
	elif N >= 1:
		ans += N // 1
		N -= N // 1 * 1
print(ans)


a = [100, 20, 10, 5, 1]
m = int(input())
t = 0
for num in a:
	t += m // num
	m %= num
print(t)


money = int(input())
ans = 0
cashes = [100, 20, 10, 5, 1]

def task(amount, cash):
	global ans
	a = amount / cash
	if a >= 0:
		ans += amount // cash
		return amount % cash
for i in cashes:
	money = task(money, i)
print(ans)


money = int(input())
count = 0
for i in (100, 20, 10, 5, 1):
	if money >= i:
		count += money // i
		money = money % i
print(count)


L = [1, 5, 10, 20, 100]
n = int(input(''))
t = 0
i = 4
while n > 0:
	while n < L[i]:
		i = i - 1
	t = t + n // L[i]
	n = n - n // L[i] * L[i]
print(t)


money = int(input())
num = money // 100 + money % 100 // 20 + money % 100 % 20 // 10 + money % 100 % 20 % 10 // 5 + money % 100 % 20 % 10 % 5 // 1
print(num)


n = input()
n = int(n)
d = [100, 20, 10, 5, 1]
notes = 0
i = 0
while n > 0:
	notes = notes + n // d[i]
	n = n % d[i]
	i = i + 1
print(notes)


V = int(input())
coins = [1, 5, 10, 20, 100]
coins = coins[::-1]
m = len(coins)
cnt = 0
i = 0
while V != 0:
	if V >= coins[i]:
		cnt += 1
		V -= coins[i]
	else:
		i += 1
print(cnt)


n = int(input())
amt = n // 100 + n % 100 // 20 + n % 100 % 20 // 10 + n % 100 % 20 % 10 // 5 + n % 100 % 20 % 10 % 5 // 1
print(amt)


import math
n = int(input())
count = 0
bills = [1, 5, 10, 20, 100]
for i in range(len(bills) - 1, -1, -1):
	if n > 0:
		n_bills = math.floor(n / bills[i])
		count += n_bills
		n -= n_bills * bills[i]
print(count)


import sys
input = sys.stdin.readline

def main():
	n = int(input())
	money_s = [100, 20, 10, 5, 1]
	ans = 0
	for m in money_s:
		ans += n // m
		n %= m
	print(ans)
main()


lis = [1, 5, 10, 20, 100]
n = int(input())
lis = lis[::-1]
ans = 0
for i in lis:
	if i > n:
		continue
	temp = n // i
	n = n % i
	ans += temp
print(ans)


inp = int(input())
i = 0
while inp > 0:
	if inp >= 100:
		inp = inp - 100
	elif inp >= 20:
		inp = inp - 20
	elif inp >= 10:
		inp = inp - 10
	elif inp >= 5:
		inp = inp - 5
	else:
		inp = inp - 1
	i = i + 1
print(i)


denom = [100, 20, 10, 5, 1]
amount = int(input())
note = denom[0]
inc = 0
bills = 0
while amount:
	if amount >= note:
		amount -= note
		bills += 1
	else:
		inc += 1
		note = denom[inc]
print(bills)


n = int(input())
i = 0
while n != 0:
	if n >= 10000:
		n -= 10000
		i += 100
	elif n >= 1000:
		n -= 1000
		i += 10
	elif n >= 100:
		n -= 100
		i += 1
	elif n >= 20:
		n -= 20
		i += 1
	elif n >= 10:
		n -= 10
		i += 1
	elif n >= 5:
		n -= 5
		i += 1
	elif n >= 1:
		n -= 1
		i += 1
print(i)


n = int(input())
c = 0
for i in [100, 20, 10, 5, 1]:
	if i > n:
		continue
	c += n // i
	n = n % i
	if n == 0:
		break
print(c)


n = int(input())
delitel = [100, 20, 10, 5, 1]
kol = 0
for d in delitel:
	kol += n // d
	n = n % d
	if n == 0:
		break
print(kol)


a = input()
a = int(a)
arr = [100, 20, 10, 5, 1]
count = 0
for num in arr:
	b = a // num
	if b > 0:
		count = count + b
	c = a % num
	if c > 0:
		a = c
	else:
		break
print(count)


bank = input()
bank = int(bank)
nota1 = 0
nota5 = 0
nota10 = 0
nota20 = 0
nota100 = 0
if bank - 100 >= 0:
	nota100 = bank // 100
	bank = bank - 100 * nota100
if bank - 20 >= 0:
	nota20 = bank // 20
	bank = bank - 20 * nota20
if bank - 10 >= 0:
	nota10 = bank // 10
	bank = bank - 10 * nota10
if bank - 5 >= 0:
	nota5 = bank // 5
	bank = bank - 5 * nota5
if bank - 1 >= 0:
	nota1 = bank // 1
	bank = bank - 1 * nota1
print(nota1 + nota5 + nota10 + nota20 + nota100)


bills = [100, 20, 10, 5, 1]
n = int(input())
nb = 0
for bill in bills:
	while n - bill >= 0:
		nb += n // bill
		n %= bill
print(str(int(nb)))


n = int(input())
a = n // 100
b = n // 10 % 10
c = n % 10
print(a + b // 2 + b % 2 + c // 5 + c % 5)


bills = [100, 20, 10, 5, 1]
amount = int(input())
count = 0
for i in bills:
	count += amount // i
	amount = amount % i
print(count)


n = int(input())
a = [100, 20, 10, 5, 1]
count = 0
for i in range(len(a)):
	if n >= a[i]:
		count = count + n // a[i]
		n = n % a[i]
print(count)


n = int(input(''))
bill = 0
if n >= 100:
	bill = int(n / 100)
	n = n % 100
if n >= 20:
	bill = bill + int(n / 20)
	n = n % 20
if n >= 10:
	bill = bill + int(n / 10)
	n = n % 10
if n >= 5:
	bill = bill + int(n / 5)
	n = n % 5
print(bill + n)


n = int(input())
k = 0
c = [100, 20, 10, 5, 1]
for i in c:
	if n >= i:
		k = k + n // i
		n = n % i
print(k)


def main():
	total_dollars = int(input().strip())
	total_bills = 0
	while total_dollars:
		if total_dollars >= 100:
			total_bills += total_dollars // 100
			total_dollars %= 100
			continue
		if total_dollars >= 20:
			total_bills += total_dollars // 20
			total_dollars %= 20
			continue
		if total_dollars >= 10:
			total_bills += total_dollars // 10
			total_dollars %= 10
			continue
		if total_dollars >= 5:
			total_bills += total_dollars // 5
			total_dollars %= 5
			continue
		total_bills += total_dollars
		total_dollars = 0
	print(total_bills)
main()


li = [100, 20, 10, 5, 1]
n = int(input())
i = 0
result = 0
while n:
	if n >= li[i]:
		result = result + n // li[i]
		n = n % li[i]
	i = i + 1
print(result)


def withdraw(n):
	notes = 0
	(q1, r1) = divmod(n, 100)
	notes += q1
	(q2, r2) = divmod(r1, 20)
	notes += q2
	(q3, r3) = divmod(r2, 10)
	notes += q3
	(q4, r4) = divmod(r3, 5)
	notes += q4
	(q5, r5) = divmod(r4, 1)
	notes += q5
	return notes

def main():
	money = int(input())
	print(withdraw(money))
main()


n = input()
n = int(n)

def countCurrency(amount):
	bills_needed = 0
	notes = [100, 20, 10, 5, 1]
	noteCounter = [0, 0, 0, 0, 0]
	for (i, j) in zip(notes, noteCounter):
		if amount >= i:
			j = amount // i
			amount = amount - j * i
			bills_needed += j
	print(bills_needed)
countCurrency(n)


den = [100, 20, 10, 5, 1]
n = int(input())
res = 0
for i in range(len(den)):
	if n >= den[i]:
		res += n // den[i]
		n = n % den[i]
print(res)


import math
inp = lambda : (int, input().split())
n = int(input())
res = 0
for i in (100, 20, 10, 5):
	res += n // i
	n = n % i
print(res + n)


n = int(input())
ans = 0
if n >= 100:
	ans += n // 100
	n = n % 100
	if n % 100 == 0:
		print(ans)
		exit()
if n >= 20:
	ans += n // 20
	n = n % 20
	if n % 20 == 0:
		print(ans)
		exit()
if n >= 10:
	ans += n // 10
	n = n % 10
	if n % 10 == 0:
		print(ans)
		exit()
if n >= 5:
	ans += n // 5
	n = n % 5
	if n % 5 == 0:
		print(ans)
		exit()
ans += n
print(ans)


def doit(money, counter, c):
	cash = [100, 20, 10, 5, 1]
	m = money % cash[counter]
	if m == 0:
		c += money // cash[counter]
		return c
	else:
		c += money // cash[counter]
		counter += 1
		return doit(m, counter, c)
a = int(input())
print(doit(a, 0, 0))


n = int(input())
note = 0
li = [100, 20, 10, 5, 1]
for i in li:
	note += n // i
	n = n % i
print(note)


n = int(input())
t1 = 100
t2 = 20
t3 = 10
t4 = 5
t5 = 1
x1 = n // t1
x2 = n % t1 // t2
x3 = n % t1 % t2 // t3
x4 = n % t1 % t2 % t3 // t4
x5 = n % t1 % t2 % t3 % t4
print(x1 + x2 + x3 + x4 + x5)


n = int(input())
k = n // 100
n = n % 100
k1 = n // 20
n = n % 20
k2 = n // 10
n = n % 10
k3 = n // 5
n = n % 5
print(k + k1 + k2 + k3 + n)


n = int(input())
j = 0
o = 0
k = [20, 10, 5, 1]
t = n // 100
n = n - n // 100 * 100
for d in k:
	while n - d >= 0:
		n = n - d
		o += 1
print(o + t)


n = int(input())
a = [100, 20, 10, 5, 1]
c = 0
while n > 0:
	c = c + n // a[0]
	n = n % a[0]
	a.pop(0)
print(c)


x = int(input())
bills = 0
bills += x // 100
x -= x // 100 * 100
bills += x // 20
x -= x // 20 * 20
bills += x // 10
x -= x // 10 * 10
bills += x // 5
x -= x // 5 * 5
bills += x // 1
x -= x // 1
print(bills)


n = int(input().strip())
a = [100, 20, 10, 5, 1]
count = 0
i = 0
while n > 0:
	if a[i] <= n:
		count = count + n // a[i]
		n = n % a[i]
		i += 1
	else:
		i += 1
print(count)


getInput = int(input())
value100 = getInput // 100
remaining = getInput - 100 * value100
value20 = remaining // 20
remaining = remaining - 20 * value20
value10 = remaining // 10
remaining = remaining - 10 * value10
value5 = remaining // 5
remaining = remaining - 5 * value5
total = remaining + value5 + value10 + value20 + value100
print(total)


s = 0
a = int(input())
b = [100, 20, 10, 5]
for i in range(0, 4):
	if a >= b[i]:
		a / b[i]
		s = s + a // b[i]
		a = a % b[i]
print(s + a % 5)


withdraw = int(input())
bills = 0
while withdraw != 0:
	if withdraw - 100 >= 0:
		withdraw -= 100
		bills += 1
	elif withdraw - 20 >= 0:
		withdraw -= 20
		bills += 1
	elif withdraw - 10 >= 0:
		withdraw -= 10
		bills += 1
	elif withdraw - 5 >= 0:
		withdraw -= 5
		bills += 1
	else:
		withdraw -= 1
		bills += 1
print(bills)


i = int(input())
w = i // 100
i = i - w * 100
x = i // 20
i = i - x * 20
z = i // 10
i = i - z * 10
c = i // 5
i = i - c * 5
a = i
i = 0
print(w + x + z + c + a)


n = int(input())
k = s = 0
money = [100, 20, 10, 5, 1]
for i in money:
	k = n // i
	n -= i * k
	s += k
print(s)


import sys
n = int(sys.stdin.readline())
denom = [100, 20, 10, 5, 1]

def lottery(n):
	bills = 0
	withdrew = 0
	i = 0
	while n != 0:
		bills += n // denom[i]
		n = n - n // denom[i] * denom[i]
		i += 1
	print(bills)
lottery(n)


n = int(input())
l = [1, 5, 10, 20, 100]
i = len(l) - 1
c = 0
while n > 0:
	c = c + n // l[i]
	n = n % l[i]
	i = i - 1
print(c)


n = int(input())
op = n // 100
n %= 100
op += n // 20
n %= 20
op += n // 10
n %= 10
op += n // 5
n %= 5
op += n // 1
print(op)


def main():
	sum_bills = 0
	n = int(input())
	bills = [100, 20, 10, 5, 1]
	for i in range(len(bills)):
		sum_bills += n // bills[i]
		n = n - bills[i] * (n // bills[i])
	print(sum_bills)
main()


def m(n, pos):
	if n == 0:
		return 0
	if n >= coins[pos]:
		return n // coins[pos] + m(n - coins[pos] * (n // coins[pos]), pos)
	elif n < coins[pos]:
		return m(n, pos - 1)
pos = 4
coins = [1, 5, 10, 20, 100]
print(m(int(input()), 4))


import math
from collections import deque

def ii():
	return int(input())

def mii():
	return map(int, input().split())

def matr(n):
	return [list(minp()) for _ in range(n)]
n = [1, 5, 10, 20, 100]
k = ii()
ans = []
for i in reversed(n):
	ans.append(k // i)
	k %= i
print(sum(ans))


i1 = int(input())
counter = 0
counter = i1 // 100
i1 %= 100
counter += i1 // 20
i1 %= 20
counter += i1 // 10
i1 %= 10
counter += i1 // 5
i1 %= 5
counter += i1 // 1
print(counter)


n = int(input())
c1 = n // 100
remain = n % 100
c2 = remain // 20
remain = remain % 20
c3 = remain // 10
remain = remain % 10
c4 = remain // 5
remain = remain % 5
c5 = remain
total = c1 + c2 + c3 + c4 + c5
print(total)


n = int(input())
t = n // 100
n = n - t * 100
tw = n // 20
n = n - tw * 20
fh = n // 50
n = n - fh * 50
tn = n // 10
n = n - tn * 10
f = n // 5
n = n - f * 5
print(t + tw + fh + tn + f + n)


x = int(input())
n = 0
while x >= 100000000:
	x = x - 100000000
	n = n + 1000000
while x >= 100:
	x = x - 100
	n = n + 1
while x >= 20:
	x = x - 20
	n = n + 1
while x >= 10:
	x = x - 10
	n = n + 1
while x >= 5:
	x = x - 5
	n = n + 1
while x >= 1:
	x = x - 1
	n = n + 1
print(int(n))


denom = [100, 20, 10, 5, 1]
n = int(input())
c = [0, 0, 0, 0, 0]
res = 0
count = 0
for x in range(1, 10 ** 9):
	y = 1
	if n >= denom[0]:
		res = n // (denom[0] * y)
		n = n - denom[0] * res
		c[0] += res
		y = y + 1
		continue
	elif n >= denom[1]:
		res = n // (denom[1] * y)
		n = n - denom[1] * res
		c[1] += res
		y = y + 1
		continue
	elif n >= denom[2]:
		res = n // (denom[2] * y)
		n = n - denom[2] * res
		c[2] += res
		y = y + 1
		continue
	elif n >= denom[3]:
		res = n // (denom[3] * y)
		n = n - denom[3] * res
		y = y + 1
		c[3] += res
		continue
	elif n >= denom[4]:
		res = n // (denom[4] * y)
		n = n - denom[4] * res
		c[4] += res
		y = y + 1
		continue
	elif n == 0:
		count = c[1] + c[2] + c[3] + c[4] + c[0]
		print(count)
		exit()


ans = 0
n = int(input())
t = n // 100
n -= t * 100
ans += t
t = n // 20
n -= t * 20
ans += t
t = n // 10
n -= t * 10
ans += t
t = n // 5
n -= t * 5
ans += t
t = n // 1
n -= t * 1
ans += t
print(ans, end='')


money = [100, 20, 10, 5, 1]
n = int(input())
count = 0
i = 0
while n > 0:
	if n >= money[i]:
		count = count + 1
		n = n - money[i]
	else:
		i = i + 1
print(count)


money = int(input())
one_hundred = money // 100
twenty = money % 100 // 20
ten = money % 100 % 20 // 10
five = money % 100 % 20 % 10 // 5
one = money % 100 % 20 % 10 % 5
print(one + five + ten + twenty + one_hundred)


n = int(input())
temp = n
days = 0
hundred = temp // 100
n = n - hundred * 100
days += hundred
temp = n
twenty = temp // 20
n = n - twenty * 20
days += twenty
temp = n
ten = temp // 10
n = n - ten * 10
days += ten
temp = n
five = temp // 5
n = n - five * 5
days += five
temp = n
one = temp
days += one
print(days)


def hitLotery(n):
	count = 0
	while n != 0:
		if n >= 100:
			n -= 100
		elif n >= 20:
			n -= 20
		elif n >= 20:
			n -= 20
		elif n >= 10:
			n -= 10
		elif n >= 5:
			n -= 5
		elif n >= 1:
			n -= 1
		count += 1
	return count
n = int(input())
print(hitLotery(n))


n = int(input(''))
count = 0

def bill_calculator(n):
	global count
	if n == 0:
		print(count)
	elif n >= 100:
		z = int(n / 100)
		x = n - 100 * z
		count = count + z
		bill_calculator(x)
	elif n >= 20:
		z = int(n / 20)
		x = n - 20 * z
		count = count + z
		bill_calculator(x)
	elif n >= 10:
		z = int(n / 10)
		x = n - 10 * z
		count = count + z
		bill_calculator(x)
	elif n >= 5:
		z = int(n / 5)
		x = n - 5 * z
		count = count + z
		bill_calculator(x)
	elif n >= 1:
		z = int(n / 1)
		x = n - 1 * z
		count = count + z
		bill_calculator(x)
bill_calculator(n)


n = int(input())
arr = [1, 5, 10, 20, 100]
tmp = 0
while n > 0:
	tmp += n // arr[-1]
	n -= arr[-1] * (n // arr[-1])
	arr.pop(-1)
print(tmp)


money = int(input())
counter = 0
if money >= 100:
	counter = counter + money // 100
	money = money - money // 100 * 100
if money >= 20:
	counter = counter + money // 20
	money = money - money // 20 * 20
if money >= 10:
	counter = counter + money // 10
	money = money - money // 10 * 10
if money >= 5:
	counter = counter + money // 5
	money = money - money // 5 * 5
if money >= 1:
	counter = counter + money // 1
	money = money - money // 5 * 5
print(counter)


n = int(input())
nr = 0
for x in [100, 20, 10, 5]:
	nr += n // x
	n %= x
nr += n
print(nr)


n = int(input())
X = []
X.append(n // 100)
n = n % 100
X.append(n // 20)
n = n % 20
X.append(n // 10)
n = n % 10
X.append(n // 5)
n = n % 5
X.append(n)
print(sum(X))


a = [1, 5, 10, 20, 100]
c = 0
n = int(input())
for i in range(len(a) - 1, -1, -1):
	c += n // a[i]
	n = n % a[i]
print(c)


n = int(input())
ans = 0
for i in [100, 20, 10, 5, 1]:
	(q, r) = (n // i, n % i)
	ans += q
	n = r
print(ans)


n = int(input())
n100 = n // 100
n20 = (n - n100 * 100) // 20
n10 = (n - (n100 * 100 + n20 * 20)) // 10
n5 = (n - (n100 * 100 + n20 * 20 + n10 * 10)) // 5
n1 = n - (n100 * 100 + n20 * 20 + n10 * 10 + n5 * 5)
print(n100 + n10 + n20 + n5 + n1)


n = int(input())
bill_vec = [100, 20, 10, 5, 1]
n_bills = 0
i_bill = 0
while i_bill < len(bill_vec) and n > 0:
	dm = divmod(n, bill_vec[i_bill])
	n_bills += dm[0]
	n = int(dm[1])
	i_bill += 1
print(n_bills)


n = int(input())
notas = [100, 20, 10, 5, 1]
qtd = 0
for nota in notas:
	qtd += int(n / nota)
	n = n % nota
print(qtd)


def res(n):
	bill = [100, 20, 10, 5, 1]
	count = 0
	for i in bill:
		if n >= i:
			q = n // i
			count += q
			n = n % i
		else:
			continue
	return count
n = int(input())
print(res(n))


x = int(input())
num = 0
for i in (100, 20, 10, 5, 1):
	if x // i:
		num += x // i
		x -= x // i * i
print(num)


n = int(input())
l = [100, 20, 10, 5, 1]
s = 0
for i in range(5):
	if n >= l[i]:
		x = n % l[i]
		c = n - x
		s = s + int(c / l[i])
		n = x
print(s)


n = int(input())
out = 0
while n > 0:
	if n // 100 > 0:
		n = n - 100
		out += 1
	elif n // 20 > 0:
		n = n - 20
		out += 1
	elif n // 10 > 0:
		n = n - 10
		out += 1
	elif n // 5 > 0:
		n = n - 5
		out += 1
	elif n // 1 > 0:
		n = n - 1
		out += 1
print(out)


value = int(input())
bills = 0

def get_bills(amount, money):
	return (money, 0) if money // amount < 1 else (money - money // amount * amount, money // amount)
for i in [100, 20, 10, 5]:
	(value, bill) = get_bills(i, value)
	bills += bill
if value >= 1:
	bills += value
print(bills)


bills = 0
den = [100, 20, 10, 5, 1]
n = int(input())
for d in range(len(den)):
	b = n // den[d]
	if b > 0:
		bills += n // den[d]
		n = n % den[d]
print(int(bills))


def min_banknotes(total):
	banknotes = [100, 20, 10, 5, 1]
	banknotes_amount = 0
	rest = total
	for b in banknotes:
		if rest == 0:
			break
		(amount, rest) = divmod(rest, b)
		banknotes_amount += amount
	return banknotes_amount
total = int(input())
print(min_banknotes(total))


b = [100, 20, 10, 5, 1]
n = int(input())
i = 0
bills = 0
while n > 0:
	red = n // b[i]
	n -= red * b[i]
	bills += red
	i += 1
print(bills)


money = int(input())
bills = [100, 20, 10, 5, 1]
count = 0
for i in range(len(bills)):
	count += money // bills[i]
	money = money % bills[i]
print(count)


import math
money = list(map(int, input().strip().split()))[0]
bill = [100, 20, 10, 5, 1]
num = 0
if money >= 1000:
	opti = math.floor(money / 100)
	money -= 100 * opti
	num += opti
for j in range(5):
	while money - bill[j] >= 0:
		money -= bill[j]
		num += 1
print(num)


balance = int(input())
sum = 0
bills = [100, 20, 10, 5, 1]
for i in bills:
	while True:
		if balance >= i:
			sum += balance // i
			balance %= i
		else:
			break
print(sum)


n = int(input())
res = n // 100
n = n % 100
res += n // 20
n = n % 20
res += n // 10
n = n % 10
res += n // 5
n = n % 5
res += n // 1
n = n % 1
print(res)


n = int(input())
r = 0
ar = [100, 20, 10, 5, 1]
for i in ar:
	r += n // i
	n = n % i
print(r)


n = int(input())
count = 0
for v in [100, 20, 10, 5, 1]:
	count += n // v
	n -= n // v * v
	if n == 0:
		break
print(count)


a = int(input())
k = 0
while a - 1000000000 >= 0:
	a = a - 1000000000
	k = k + 10000000
while a - 100000000 >= 0:
	a = a - 100000000
	k = k + 1000000
while a - 10000000 >= 0:
	a = a - 10000000
	k = k + 100000
while a - 1000000 >= 0:
	a = a - 1000000
	k = k + 10000
while a - 100000 >= 0:
	a = a - 100000
	k = k + 1000
while a - 10000 >= 0:
	a = a - 10000
	k = k + 100
while a - 1000 >= 0:
	a = a - 1000
	k = k + 10
while a - 100 >= 0:
	a = a - 100
	k = k + 1
while a - 20 >= 0:
	a = a - 20
	k = k + 1
while a - 10 >= 0:
	a = a - 10
	k = k + 1
while a - 5 >= 0:
	a = a - 5
	k = k + 1
while a - 1 >= 0:
	a = a - 1
	k = k + 1
print(k)


c = [100, 20, 10, 5, 1]
a = int(input())
tot = 0
for i in range(0, 5):
	if c[i] <= a:
		tot = tot + a // c[i]
		a = a % c[i]
print(tot)


while 1:
	try:
		n = int(input())
		print(n // 100 + n % 100 // 20 + n % 20 // 10 + n % 10 // 5 + n % 5)
	except EOFError:
		break


import sys
import math
input = sys.stdin.readline

def inp():
	return int(input())

def inara():
	return list(map(int, input().split()))

def insr():
	s = input()
	return list(s[:len(s) - 1])

def invr():
	return map(int, input().split())
n = inp()
note = [1, 5, 10, 20, 100]
ans = 0
for i in range(4, -1, -1):
	while n >= note[i]:
		n -= note[i]
		ans += 1
print(ans)


a = int(input())
k = 0
while a > 0 or a != 0:
	if a >= 100:
		k += a // 100
		a %= 100
	elif a >= 20:
		k += a // 20
		a %= 20
	elif a >= 10:
		k += a // 10
		a %= 10
	elif a >= 5:
		k += a // 5
		a %= 5
	elif a >= 1:
		k += a // 1
		a %= 1
print(k)


curr = int(input())
n = 0
while curr > 0:
	if curr // 100 >= 0:
		n += curr // 100
		curr -= curr // 100 * 100
	if curr // 20 >= 0:
		n += curr // 20
		curr -= curr // 20 * 20
	if curr // 10 >= 0:
		n += curr // 10
		curr -= curr // 10 * 10
	if curr // 5 >= 0:
		n += curr // 5
		curr -= curr // 5 * 5
	if curr >= 0:
		n += curr
		curr = 0
print(n)


n = int(input())
arr = [100, 20, 10, 5, 1]
bills = 0
for i in range(len(arr)):
	bills += n // arr[i]
	n = n % arr[i]
	if n == 0:
		print(bills)
		break


n = int(input())
notes = n // 100 + n % 100 // 20 + n % 100 % 20 // 10 + n % 100 % 20 % 10 // 5 + n % 100 % 20 % 10 % 5
print(notes)


n = int(input())
answer = 0
answer += n // 100
n = n % 100
answer += n // 20
n = n % 20
answer += n // 10
n = n % 10
answer += n // 5
n = n % 5
answer += n
print(answer)


I = input
x = int(I())
ans = 0
ls = [100, 20, 10, 5, 1]
for i in ls:
	if x >= i:
		ans += x // i
		x = x % i
print(ans)


bills = (100, 20, 10, 5, 1)
w = int(input())
n = 0
for k in bills:
	nk = w // k
	w -= k * nk
	n += nk
print(n)


v = 0
q = 0
it = 0
s = input()
s = int(s)
v = v + s // 100
s = s % 100
v = v + s // 20
s = s % 20
v = v + s // 10
s = s % 10
v = v + s // 5
s = s % 5
v = v + s // 1
s = s % 1
print(str(v))


n = int(input())
coins = [1, 5, 10, 20]
supl = 0
if n >= 100:
	bills = n // 100
	n = n % 100
	supl = bills
dp = [float('inf') for _ in range(n + 1)]
dp[0] = 0
for i in range(1, n + 1):
	candidates = [dp[i - k] + 1 for k in coins if i >= k]
	dp[i] = min(candidates)
print(dp[n] + supl)


n = int(input())

def g(n):
	j = n
	t = 0
	c = 0
	if n >= 100:
		t = j // 100
		j -= t * 100
		c += t
		if j >= 20:
			t = j // 20
			j -= t * 20
			c += t
			if j >= 10:
				t = j // 10
				j -= t * 10
				c += t
				if j >= 5:
					t = j // 5
					j -= t * 5
					c += t
					if j >= 5:
						t = j // 5
						j -= t * 5
						c += t
						if j < 5:
							return c + j
		elif j >= 10:
			t = j // 10
			j -= t * 10
			c += t
			if j >= 5:
				t = j // 5
				j -= t * 5
				c += t
				if j < 5:
					return c + j
		elif j >= 5:
			t = j // 5
			j -= t * 5
			c += t
			if j < 5:
				return c + j
		elif j < 5:
			return c + j
	if n >= 20:
		t = j // 20
		j -= t * 20
		c += t
		if j >= 10:
			t = j // 10
			j -= t * 10
			c += t
			if j >= 5:
				t = j // 5
				j -= t * 5
				c += t
				if j < 5:
					return c + j
		elif j >= 5:
			t = j // 5
			j -= t * 5
			c += t
			if j < 5:
				return c + j
		elif j < 5:
			return c + j
	if n >= 10:
		t = j // 10
		j -= t * 10
		c += t
		if j >= 5:
			t = j // 5
			j -= t * 5
			c += t
			if j < 5:
				return c + j
		elif j < 5:
			return c + j
	if n >= 5:
		t = j // 5
		j -= t * 5
		c += t
		if j < 5:
			return c + j
	if n < 5:
		return n
print(g(n))


denoms = [1, 5, 10, 20, 100]
amount = int(input())
sum = 0
count = 0
while denoms != [] and amount:
	count += amount // denoms[-1]
	amount = amount % denoms[-1]
	del denoms[-1]
print(count)


bank_account = int(input())
total = 0
for i in [100, 20, 10, 5, 1]:
	if i > bank_account:
		continue
	else:
		temp = bank_account // i
		total += temp
		bank_account -= temp * i
print(total)


money = int(input())
m100 = money // 100
money -= 100 * m100
m20 = money // 20
money -= 20 * m20
m10 = money // 10
money -= 10 * m10
m5 = money // 5
money -= 5 * m5
m1 = money
assert m1 <= 4
print(m100 + m20 + m10 + m5 + m1)


string = input()
ls = list(map(int, string.split(' ')))
note = 0
note += int(ls[0] / 100)
ls[0] = ls[0] % 100
note += int(ls[0] / 20)
ls[0] = ls[0] % 20
note += int(ls[0] / 10)
ls[0] = ls[0] % 10
note += int(ls[0] / 5)
ls[0] = ls[0] % 5
note += int(ls[0] / 1)
print(note)


import os
import sys

def get_int():
	return int(input())

def get_ints():
	return map(int, input().split())

def get_float():
	return float(input())

def get_floats():
	return map(float, input().split())

def list_ints():
	return list(map(int, input().split()))

def list_floats():
	return list(map(float, input.split()))

def post(x):
	print(x, end=' ')
T = int(input())
res = 0
if T // 100:
	res += T // 100
	T -= T // 100 * 100
if T // 20:
	res += T // 20
	T -= T // 20 * 20
if T // 10:
	res += T // 10
	T -= T // 10 * 10
if T // 5:
	res += T // 5
	T -= T // 5 * 5
res += T
print(res)


n = int(input())
cash = [100, 20, 10, 5, 1]
res = 0
i = 0
while n:
	res += n // cash[i]
	n = n % cash[i]
	i += 1
print(res)


k = 0
x = int(input())
while x > 0:
	if x // 100 > 0:
		k += x // 100
		x -= x // 100 * 100
	elif x // 20 > 0:
		k += x // 20
		x -= x // 20 * 20
	elif x // 10 > 0:
		k += x // 10
		x -= x // 10 * 10
	elif x // 5 > 0:
		k += x // 5
		x -= x // 5 * 5
	else:
		k += x // 1 * 1
		x -= x // 1 * 1
print(k)


money = int(input())
bills = 0
bills = money // 100
money = money % 100
bills = money // 20 + bills
money = money % 20
bills = money // 10 + bills
money = money % 10
bills = money // 5 + bills
money = money % 5
print(money + bills)


input_ = int(input())
nominals = [1, 5, 10, 20, 100]
cash = 0
for i in sorted(nominals, reverse=True):
	cash += input_ // i
	input_ = input_ - input_ // i * i
print(cash)


import math
dollars = int(input())
bills = [100, 20, 10, 5, 1]
no_of_bills = 0
for bill in bills:
	no_of_bills += math.floor(dollars / bill)
	dollars = dollars % bill
print(no_of_bills)


x = int(input())
y = x
z = y // 100
x1 = y - z * 100
if x1 == 0:
	print(z)
	exit(0)
z1 = x1 // 20
x2 = x1 - z1 * 20
if x2 == 0:
	print(z + z1)
	exit(0)
z2 = x2 // 10
x3 = x2 - z2 * 10
if x3 == 0:
	print(z + z1 + z2)
	exit(0)
z3 = x3 // 5
x4 = x3 - 5 * z3
if x4 == 0:
	print(z + z1 + z2 + z3)
	exit(0)
print(x4 + z + z1 + z2 + z3)


n = int(input())
sum = 0
while n >= 100:
	sum += 1
	n -= 100
while n >= 20:
	sum += 1
	n -= 20
while n >= 10:
	sum += 1
	n -= 10
while n >= 5:
	sum += 1
	n -= 5
while n >= 1:
	sum += 1
	n -= 1
print(sum)


def get_min_notes(n):
	NOTES = [100, 20, 10, 5, 1]
	min_notes = 0
	for note in NOTES:
		min_notes += n // note
		n = n % note
	return min_notes
n = int(input())
print(get_min_notes(n))


n = int(input())
rem = n % 5
count = 0
while n > 4:
	if n >= 100:
		count += n // 100
		n = n % 100
	elif n >= 20:
		count += n // 20
		n = n % 20
	elif n >= 10:
		count += n // 10
		n = n % 10
	elif n >= 5:
		count += n // 5
		n = n % 5
print(count + rem)


n = int(input().strip())
noms = [100, 20, 10, 5, 1]
cnt = 0
nr = n
for nom in noms:
	(dc, nr) = divmod(nr, nom)
	cnt += dc
print(cnt)


n = int(input())
res = 0
x = int(n / 100)
res += x
n -= 100 * x
if n > 0:
	x = int(n / 20)
	res += x
	n -= 20 * x
if n > 0:
	x = int(n / 10)
	res += x
	n -= 10 * x
if n > 0:
	x = int(n / 5)
	res += x
	n -= 5 * x
if n > 0:
	x = int(n / 1)
	res += x
	n -= 1 * x
print(res, end='')


a = int(input())
n = 0
while a >= 100:
	k = a // 100
	n += k
	a -= k * 100
while a >= 20:
	k = a // 20
	n += k
	a -= k * 20
while a >= 10:
	k = a // 10
	n += k
	a -= k * 10
while a >= 5:
	k = a // 5
	n += k
	a -= k * 5
while a >= 1:
	k = a // 1
	n += k
	a -= k * 1
print(n)


n = int(input())
bills = 0
bills += n // 100
n = n % 100
bills += n // 20
n = n % 20
bills += n // 10
n = n % 10
bills += n // 5
n = n % 5
bills += n // 1
print(bills)


cash = int(input())
counter = 0
counter += int(cash / 100)
cash -= counter * 100
while cash > 0:
	if cash >= 20:
		cash -= 20
		counter += 1
		continue
	if cash >= 10:
		cash -= 10
		counter += 1
		continue
	if cash >= 5:
		cash -= 5
		counter += 1
		continue
	if cash >= 1:
		cash -= 1
		counter += 1
print(counter)


def denominations(amount):
	bills = int(amount / 100)
	amount = amount % 100
	bills += int(amount / 20)
	amount = amount % 20
	bills += int(amount / 10)
	amount = amount % 10
	bills += int(amount / 5)
	amount = amount % 5
	bills += int(amount / 1)
	amount = amount % 1
	return bills
n = int(input())
print(denominations(n))


a = int(input())
c = 0
k = 0
for i in [100, 20, 10, 5, 1]:
	c = a // i
	k = k + a // i
	a = a - c * i
print(k)


n = int(input())

def getBillsCount(amount, bills):
	count = 0
	for bill in sorted(bills, reverse=True):
		if amount == 0:
			break
		numOfBills = amount // bill
		if numOfBills > 0:
			amount -= bill * numOfBills
			count += numOfBills
	return count
billsValues = [1, 5, 10, 20, 100]
print(getBillsCount(n, billsValues))


import math
n = int(input())
sum = int(n / 100)
n %= 100
sum += int(n / 20)
n %= 20
sum += int(n / 10)
n %= 10
sum += int(n / 5)
n %= 5
sum += int(n / 1)
print(sum)


import math
Result = 0
Denominations = [100, 20, 10, 5, 1]
n = int(input())
for i in range(len(Denominations)):
	if Denominations[i] <= n:
		break
for j in range(i, len(Denominations)):
	NumberOfBills = math.trunc(n / Denominations[j])
	Result += NumberOfBills
	n -= NumberOfBills * Denominations[j]
print(Result)


n = int(input())
x = 0
y = 0
while n != 0:
	while n >= 100:
		x = n // 100
		y += x
		n %= 100
	while n >= 20:
		x = n // 20
		y += x
		n %= 20
	while n >= 10:
		x = n // 10
		y += x
		n %= 10
	while n >= 5:
		x = n // 5
		y += x
		n %= 5
	while n >= 1:
		n -= 1
		y += 1
print(y)


n = int(input())
value = int(n / 100)
n = n % 100
value += int(n / 20)
n = n % 20
value += int(n / 10)
n = n % 10
value += int(n / 5)
n = n % 5
value += int(n)
print(value)


Saldo = int(input())
CantidadDeBilletes = 0
for Billetes in (100, 20, 10, 5):
	CantidadDeBilletes += Saldo // Billetes
	Saldo %= Billetes
print(Saldo + CantidadDeBilletes)


n = input()
n = int(n)
nums = 0
bills = [100, 20, 10, 5, 1]
for b in bills:
	bs = n // b
	nums += bs
	n = n - bs * b
print(nums)


n = int(input())
k = 0
t = n // 100
m = n % 100
if t > 0:
	k += t
a = m // 20
b = m % 20
if a > 0:
	k += a
c = b // 10
d = b % 10
if c > 0:
	k += c
e = d // 5
f = d % 5
if e > 0:
	k += e
g = f // 1
k += g
print(k)


n = int(input())
deno = [100, 20, 10, 5, 1]
tot_notes = 0
for i in range(5):
	note = n // deno[i]
	n -= note * deno[i]
	tot_notes += note
print(tot_notes)


n = int(input())
values = [100, 20, 10, 5, 1]
billCount = 0
for value in values:
	billCount += n // value
	n %= value
print(billCount)


n = int(input())
monedas = n // 100
resto = n % 100
monedas += resto // 20
resto = resto % 20
monedas += resto // 10
resto = resto % 10
monedas += resto // 5
resto = resto % 5
monedas += resto
print(monedas)


n = int(input())
count = 0
li = [100, 20, 10, 5, 1]
while n > 0:
	for i in li:
		count += n // i
		n %= i
print(count)


class Main:
	n = int(input())
	bills = 0
	for i in reversed([1, 5, 10, 20, 100]):
		bills += int(n / i)
		n = n % i
	print(bills)
Main()


k = input()
k = int(k)
cnt = 0
while k > 0:
	if k == 0:
		break
	if k < 5 and k >= 1:
		cnt += k * 1
		k = 0
	if k >= 5 and k < 10:
		c = k // 5
		k = k - 5 * c
		cnt += c
	elif k >= 10 and k < 20:
		c = k // 10
		k = k - 10 * c
		cnt += c
	elif k >= 20 and k < 100:
		c = k // 20
		k = k - 20 * c
		cnt += c
	elif k >= 100:
		c = k // 100
		k = k - 100 * c
		cnt += c
print(cnt)


n = int(input())
notes = 0
if n >= 100:
	notes += n // 100
	n = n % 100
if n >= 20:
	notes += n // 20
	n = n % 20
if n >= 10:
	notes += n // 10
	n = n % 10
if n >= 5:
	notes += n // 5
	n = n % 5
if n >= 1:
	notes += n // 1
	n = n % 1
print(notes)


n = int(input())
notes = [1, 5, 10, 20, 100]
notes.sort(reverse=True)
i = 0
count = 0
while n != 0:
	if notes[i] <= n:
		k = int(n / notes[i])
		n = n - k * notes[i]
		count += k
	else:
		i += 1
print(count)


n = int(input().strip())
a = [100, 20, 10, 5, 1]
cnt = 0
for i in a:
	cnt += n // i
	n = n % i
	if n == 0:
		break
print(cnt)


def my(chislo, x, i):
	i += int(x / chislo)
	x = x % chislo
	return (i, x)
x = int(input())
i = 0
(i, x) = my(100, x, i)
(i, x) = my(20, x, i)
(i, x) = my(10, x, i)
(i, x) = my(5, x, i)
(i, x) = my(1, x, i)
print(i)


def denomination(n):
	res = 0
	s = [100, 20, 10, 5, 1]
	for i in range(5):
		res = res + n // s[i]
		n = n % s[i]
	return res
x = int(input())
print(denomination(x))


n = int(input())
s = [100, 20, 10, 5, 1]
k = 0
for a in s:
	k += n // a
	n = n % a
print(k)


items = [1, 5, 10, 20, 100]

def dp(n):
	arr = [float('inf')] * (n + 1)
	arr[0] = 0
	for i in range(1, n + 1):
		for item in items:
			if item <= i:
				arr[i] = min(arr[i], arr[i - item])
		arr[i] += 1
	return arr[n]
n = int(input())
s = n // 100
n %= 100
s += n // 20
n %= 20
s += n // 10
n %= 10
s += n // 5
n %= 5
s += n
print(s)


n = int(input())
arr = [100, 20, 10, 5, 1]
cnt = 0
for i in arr:
	if n >= i:
		cnt += n // i
		n -= i * (n // i)
	if n < 0:
		break
print(cnt)


N = int(input())
P = 0
while N // 100 > 0:
	if N % 100 == 0:
		P += N // 100
		N = 0
		break
	else:
		P += N // 100
		N %= 100
while N // 20 > 0:
	if N % 20 == 0:
		P += N // 20
		N = 0
		break
	else:
		P += N // 20
		N %= 20
while N // 10 > 0:
	if N % 10 == 0:
		P += N // 10
		N = 0
		break
	else:
		P += N // 10
		N %= 10
while N // 5 > 0:
	if N % 5 == 0:
		P += N // 5
		N = 0
		break
	else:
		P += N // 5
		N %= 5
if N != 0:
	print(P + N)
else:
	print(P)


bills = [100, 20, 10, 5, 1]
left = int(input())
n_notes = 0
for b in bills:
	if left == 0:
		break
	(temp, left) = divmod(left, b)
	n_notes += temp
print(n_notes)


l = [100, 20, 10, 5, 1]
n = int(input())
cst = 0
i = 0
if n > 100:
	rem = n % 100
	n = n // 100
	cst = n
	n = rem
while n:
	while i < 5 and n >= l[i]:
		n -= l[i]
		cst += 1
	i += 1
print(cst)


s = int(input())
x = 0
t = int(s / 100)
x = x + t
s = s - t * 100
t = int(s / 20)
x = x + t
s = s - t * 20
t = int(s / 10)
x = x + t
s = s - t * 10
t = int(s / 5)
x = x + t
s = s - t * 5
t = int(s / 1)
x = x + t
s = s - t * 1
print(x)


num = int(input())
total = 0
if num >= 100:
	total += (num - num % 100) / 100
	num = num % 100
if num >= 20:
	total += (num - num % 20) / 20
	num = num % 20
if num >= 10:
	total += (num - num % 10) / 10
	num = num % 10
if num >= 5:
	total += (num - num % 5) / 5
	num = num % 5
total += num
print(int(total))


def main():
	amount = int(input())
	bill_factors = [100, 20, 10, 5, 1]
	bill_count = 0
	for b in bill_factors:
		bill_count += amount // b
		amount = amount % b
		if amount == 0:
			break
	print(bill_count)
main()


def solve(arr, n, dol, d):
	if dol == 0:
		return 0
	if n == 0:
		return float('inf')
	if n == 1:
		if dol % arr[n - 1] == 0:
			return dol // arr[n - 1]
		else:
			return float('inf')
	if (n, dol) in d:
		return d[n, dol]
	if arr[n - 1] <= dol:
		temp = min(dol // arr[n - 1] + solve(arr, n, dol % arr[n - 1], d), solve(arr, n - 1, dol, d))
	else:
		temp = solve(arr, n - 1, dol, d)
	d[n, dol] = temp
	return temp
dol = int(input())
arr = [1, 5, 10, 20, 100]
d = {}
print(solve(arr, 5, dol, d))


n = int(input())
bills_100 = int(n / 100)
bills_20 = int(n % 100 / 20)
bills_10 = int(n % 100 % 20 / 10)
bills_5 = int(n % 100 % 20 % 10 / 5)
bills_1 = int(n % 100 % 20 % 10 % 5)
print(bills_1 + bills_5 + bills_10 + bills_20 + bills_100)


count = 0
r = int(input())
s = list(map(int, str(r)))
if len(s) >= 3:
	count += r // 100
	if s[-2] % 2 == 0:
		count += s[-2] / 2
	else:
		count += s[-2] // 2 + 1
	if s[-1] >= 5:
		count += 1 + s[-1] - 5
	else:
		count += s[-1]
elif len(s) == 2:
	if s[0] % 2 == 0:
		count += s[0] / 2
	else:
		count += s[0] // 2 + 1
	if s[1] >= 5:
		count += 1 + s[1] - 5
	else:
		count += s[1]
elif s[0] >= 5:
	count += 1 + s[0] - 5
else:
	count += s[0]
print(int(count))


n = int(input())
denomination = [100, 20, 10, 5, 1]
count = 0
while n > 0:
	for ele in denomination:
		if ele <= n:
			n -= ele
			count += 1
			break
print(count)


def solve():
	n = int(input())
	k = 0
	k1 = n // 100
	n -= k1 * 100
	k2 = n // 20
	n -= k2 * 20
	k3 = n // 10
	n -= k3 * 10
	k4 = n // 5
	n -= k4 * 5
	k5 = n
	n -= k5
	print(k1 + k2 + k3 + k4 + k5)
solve()


num = int(input())
count = 0
x = 0
y = 0
z = 0
a = 0
b = 0
while num != 0:
	if num >= 100:
		x = int(num / 100)
		num = num - 100 * x
	elif num >= 20:
		y = int(num / 20)
		num = num - 20 * y
	elif num >= 10:
		z = int(num / 10)
		num = num - 10 * z
	elif num >= 5:
		a = int(num / 5)
		num = num - 5 * a
	else:
		b = int(num / 1)
		num = num - 1 * b
print(x + y + z + a + b)


ans = 0
x = 0

def read():
	return int(input())

def getans(a):
	global ans, x
	ans += x // a
	x = x % a
x = read()
getans(100)
getans(20)
getans(10)
getans(5)
getans(1)
print(ans)


a = int(input())
count = 0
while a != 0:
	if a >= 100:
		count += a // 100
		a = a % 100
	elif 20 <= a < 100:
		count += a // 20
		a = a % 20
	elif 10 <= a < 20:
		count += a // 10
		a = a % 10
	elif 5 <= a < 10:
		count += a // 5
		a = a % 5
	else:
		count += a // 1
		a = a % 1
print(count)


n = int(input())
denom = [100, 20, 10, 5, 1]
bills = 0
for i in range(len(denom)):
	while int(n / denom[i]) >= 1:
		num_notes = int(n / denom[i])
		n = n - num_notes * denom[i]
		bills = bills + num_notes
print(bills)


n = int(input())
a = [1, 5, 10, 20, 100]
count = 0
while n != 0:
	if n >= a[-1]:
		n = n - a[-1]
		count = count + 1
	else:
		a.pop()
print(count)


c = -0
a = int(input(''))
while a >= 0:
	if a >= 1000:
		a = a - 1000
		c = c + 10
	if a >= 100:
		a = a - 100
		c = c + 1
	elif a < 100 and a >= 20:
		a = a - 20
		c = c + 1
	elif a < 20 and a >= 10:
		a = a - 10
		c = c + 1
	elif a < 10 and a >= 5:
		a = a - 5
		c = c + 1
	elif a < 5 and a > 0:
		a = a - 1
		c = c + 1
	elif a == 0:
		print(c)
		break


coins = [100, 20, 10, 5, 1]
n = int(input())
print(n // 100 + n % 100 // 20 + n % 20 // 10 + n % 10 // 5 + n % 5 // 1)


N = int(input())
D = [1, 5, 10, 20, 100]
c = 0
for d in reversed(D):
	if not N:
		break
	if d <= N:
		(q, N) = divmod(N, d)
		c += q
print(c)


line = input()
words = []
for word in line.split():
	words.append(word)
money = int(words[0])
dollars = [100, 20, 10, 5, 1]
answer = 0
for dollar in dollars:
	if money == 0:
		break
	if dollar <= money:
		answer += int(money / dollar)
		money = money % dollar
print(answer)


bills = [100, 20, 10, 5, 1]
withdrawl = int(input())
minBills = 0
for bill in bills:
	minBills += withdrawl // bill
	withdrawl -= withdrawl // bill * bill
print(minBills)


dollar = int(input())
bills = [100, 20, 10, 5, 1]
count = 0
for bill in bills:
	count += dollar // bill
	dollar = dollar - dollar // bill * bill
	if dollar == 0:
		break
print(count)


import math
from collections import Counter
L = lambda : list(map(int, input().split()))
M = lambda : map(int, input().split())
I = lambda : int(input())
IN = lambda : input()

def s(a):
	print(''.join(list(map(str, a))))
n = I()
a = [100, 20, 10, 5, 1]
i = 0
c = 0
while n > 0:
	c += n // a[i]
	n = n % a[i]
	i += 1
print(c)


BILLS = [100, 20, 10, 5, 1]

def lottery(n):
	num_bills = 0
	for bill in BILLS:
		(num, n) = divmod(n, bill)
		num_bills += num
	return num_bills

def main():
	n = int(input())
	result = lottery(n)
	print(result)
main()


n = int(input())
result = 0
result += n // 100
n %= 100
result += n // 20
n %= 20
result += n // 10
n %= 10
result += n // 5
n %= 5
result += n // 1
n = 0
print(result)


n = int(input())
num = int(n // 100)
n %= 100
num += int(n // 20)
n %= 20
num += int(n // 10)
n %= 10
num += int(n // 5)
n %= 5
num += n
print(num)


n = int(input())
t = [100, 20, 10, 5, 1]
count = 0
for index in range(len(t)):
	n_ = n % t[index]
	i = n // t[index]
	if i == 0:
		n = n_
		continue
	else:
		count += i
		n = n_
print(count)


n = int(input())
count = 0
if n >= 100:
	temp = int(n / 100)
	count += temp
	n -= 100 * temp
if n >= 20:
	temp = int(n / 20)
	count += temp
	n -= 20 * temp
if n >= 10:
	temp = int(n / 10)
	count += temp
	n -= 10 * temp
if n >= 5:
	temp = int(n / 5)
	count += temp
	n -= 5 * temp
if n > 0:
	count += n
print(count)


money = int(input())
count = 0
if money >= 100:
	count += money // 100
	money %= 100
if money >= 20:
	count += money // 20
	money %= 20
if money >= 10:
	count += money // 10
	money %= 10
if money >= 5:
	count += money // 5
	money %= 5
if money >= 1:
	count += money
print(count)


x = int(input())
t = 0
while x >= 10000:
	t += 100
	x = x - 10000
while x >= 100:
	t += 1
	x = x - 100
while x >= 20:
	t += 1
	x = x - 20
while x >= 10:
	t += 1
	x = x - 10
while x >= 5:
	t += 1
	x = x - 5
while x >= 1:
	t += 1
	x = x - 1
print(t)


n = int(input())
cur = 0
if n >= 100:
	cur += n // 100
	n %= 100
if n >= 20:
	cur += n // 20
	n %= 20
if n >= 10:
	cur += n // 10
	n %= 10
if n >= 5:
	cur += n // 5
	n %= 5
if n >= 1:
	cur += n // 1
print(cur)


count = 0
cash = int(input(''))
balance = [100, 20, 10, 5, 1]
for i in balance:
	a = cash // i
	count += a
	cash -= a * i
print(count)


def test_0():
	import math
	from collections import Counter
	n = list(map(int, input().split(' ')))[0]
	aa = [1, 5, 10, 20, 100]
	aa.sort(reverse=1)
	a_2 = n
	cnt = 0
	for a in aa:
		if a_2 / a >= 1:
			a_1 = a_2 // a
			a_2 = a_2 % a
			cnt += a_1
	print(cnt)
test_0()


n = int(input())
l = [100, 20, 10, 5, 1]
count = k = 0
while n != 0:
	i = l[k]
	if i <= n:
		if n % i == 0:
			q = n // i
			count += q
			n = n % i
		else:
			q = n // i
			count += q
			n = n % i
	else:
		k += 1
print(count)


a = int(input())
c = 0
if a >= 100:
	x = a
	a = a % 100
	c += x // 100
if a >= 20 and a < 100:
	x = a
	a = a % 20
	c += x // 20
if a >= 10 and a < 20:
	x = a
	a = a % 10
	c += x // 10
if a >= 5 and a < 10:
	x = a
	a = a % 5
	c += x // 5
print(a + c)


nums = [100, 20, 10, 5, 1]

def main():
	n = int(input())
	k = 0
	for i in nums:
		y = n // i
		k += y
		n = n - i * y
		i += 1
	print(k)
main()


n = int(input())
ans = 0
bills = [100, 20, 10, 5, 1]
for bill in bills:
	ans += n // bill
	if n >= bill:
		n %= bill
print(ans)


import sys
n = int(input())
counter = 0
bills = [100, 20, 10, 5, 1]
for i in bills:
	counter = counter + n // i
	n = n % i
print(str(counter))


a = int(input())
(b, c, d, e, f) = (0, 0, 0, 0, 0)
if a >= 100:
	f = int(a / 100)
	a -= f * 100
if a >= 20:
	e = int(a / 20)
	a -= e * 20
if a >= 10:
	d = int(a / 10)
	a -= d * 10
if a >= 5:
	c = int(a / 5)
	a -= c * 5
if a >= 1:
	b = int(a / 1)
	a -= b * 1
print(b + c + d + e + f)


x = int(input())
bills = 0
(b, x) = divmod(x, 100)
bills += b
(b, x) = divmod(x, 20)
bills += b
(b, x) = divmod(x, 10)
bills += b
(b, x) = divmod(x, 5)
bills += b
(b, x) = divmod(x, 1)
bills += b
print(bills)


import sys
n = int(sys.stdin.readline().rstrip())
min_bills = 0
denoms = [100, 20, 10, 5, 1]
denom_index = 0
while n > 0:
	for d in denoms:
		if d <= n:
			(div, mod) = divmod(n, d)
			n = mod
			min_bills += div
print(str(min_bills) + '\n')


n = int(input())
c = 0
c += n // 100
rem = n % 100
c += rem // 20
rem = rem % 20
c += rem // 10
rem = rem % 10
c += rem // 5
rem = rem % 5
c += rem // 1
print(c)


n = int(input())
n_bills = 0
allowed = [1, 5, 10, 20, 100]
for bill in reversed(allowed):
	n_bills += n // bill
	n = n % bill
print(n_bills)


import math
numbers = list(map(int, input().split()))
n = numbers[0]
j = 0
if n >= 100:
	j = j + math.floor(n / 100)
	n = n % 100
if n >= 20:
	j = j + math.floor(n / 20)
	n = n % 20
if n >= 10:
	j = j + math.floor(n / 10)
	n = n % 10
if n >= 5:
	j = j + math.floor(n / 5)
	n = n % 5
if n >= 1:
	j = j + n
print(j)


import math as mt
import sys, string, bisect
input = sys.stdin.readline
import random
from collections import deque, defaultdict
L = lambda : list(map(int, input().split()))
Ls = lambda : list(input().split())
M = lambda : map(int, input().split())
I = lambda : int(input())
d = defaultdict(int)
a = 0
n = I()
a += n // 100
n %= 100
a += n // 20
n %= 20
a += n // 10
n %= 10
a += n // 5
n %= 5
a += n
print(a)


a = [1, 5, 10, 20, 100]
n = int(input())
ways = 0
i = 4
while n != 0:
	ways += int(n / a[i])
	if int(n / a[i]) != 0:
		n = n % a[i]
	i -= 1
print(ways)


inputs = int(input())
count = 0
if inputs > 100 or inputs == 100:
	rem = inputs % 100
	value = (inputs - rem) // 100
	count += value
	inputs = rem
if inputs > 20 or inputs == 20:
	rem = inputs % 20
	value = (inputs - rem) // 20
	count += value
	inputs = rem
if inputs > 10 or inputs == 10:
	rem = inputs % 10
	value = (inputs - rem) // 10
	count += value
	inputs = rem
if inputs > 5 or inputs == 5:
	rem = inputs % 5
	value = (inputs - rem) // 5
	count += value
	inputs = rem
if inputs > 1 or inputs == 1:
	rem = inputs % 1
	value = (inputs - rem) // 1
	count += value
	inputs = rem
print(count)


import sys
import math
import os
import itertools
import string
import heapq
import _collections
from collections import Counter
from collections import defaultdict
from functools import lru_cache
import bisect
import re
import queue

class Scanner:

	@staticmethod
	def int():
		return int(sys.stdin.readline().rstrip())

	@staticmethod
	def string():
		return sys.stdin.readline().rstrip()

	@staticmethod
	def map_int():
		return [int(x) for x in Scanner.string().split()]

	@staticmethod
	def string_list(n):
		return [input() for i in range(n)]

	@staticmethod
	def int_list_list(n):
		return [Scanner.map_int() for i in range(n)]

	@staticmethod
	def int_cols_list(n):
		return [int(input()) for i in range(n)]

class Math:

	@staticmethod
	def gcd(a, b):
		if b == 0:
			return a
		return Math.gcd(b, a % b)

	@staticmethod
	def lcm(a, b):
		return a * b // Math.gcd(a, b)

	@staticmethod
	def round_up(a, b):
		return -(-a // b)

	@staticmethod
	def is_prime(n):
		if n < 2:
			return False
		if n == 2:
			return True
		if n % 2 == 0:
			return False
		d = int(n ** 0.5) + 1
		for i in range(3, d + 1, 2):
			if n % i == 0:
				return False
		return True

class PriorityQueue:

	def __init__(self, l=[]):
		self.q = l
		heapq.heapify(self.q)
		return

	def push(self, n):
		heapq.heappush(self.q, n)
		return

	def pop(self):
		return heapq.heappop(self.q)
MOD = int(1000000000.0) + 7
INF = int(1000000000000000.0)

def main():
	N = Scanner.int()
	L = [100, 20, 10, 5, 1]
	ans = 0
	for l in L:
		ans += N // l
		N %= l
	print(ans)
main()


n = int(input())
cnt = 0
a = [100, 20, 10, 5, 1]
for v in a:
	if n == 0:
		break
	cnt = cnt + n // v
	n = n % v
print(cnt)


n = int(input())
count = 0
p = [100, 20, 10, 5, 1]
for i in range(5):
	count += n // p[i]
	n = n % p[i]
print(count)


n = int(input())
w = [100, 20, 10, 5, 1]
m = 0
for i in w:
	m = m + n // i
	n = n % i
print(m)


n = int(input())
c = 0
for i in [100, 20, 10, 5]:
	d = n // i
	c += d
	n -= d * i
c += n
print(c)


def res(n):
	c1 = 0
	if n // 100:
		c1 += n // 100
		n -= n // 100 * 100
	if n // 20:
		c1 += n // 20
		n -= n // 20 * 20
	if n // 10:
		c1 += n // 10
		n -= n // 10 * 10
	if n // 5:
		c1 += n // 5
		n -= n // 5 * 5
	c1 += n
	print(c1)
n = int(input())
res(n)


n = int(input())
j = 0
while 1:
	if n == 0:
		break
	if n >= 100:
		n -= 100
		j += 1
		continue
	elif n >= 20:
		n -= 20
		j += 1
		continue
	elif n >= 10:
		n -= 10
		j += 1
		continue
	elif n >= 5:
		n -= 5
		j += 1
		continue
	elif n >= 1:
		n -= 1
		j += 1
		continue
print(j)


import math
import random
mod = 1000000007
r1 = lambda : int(input())
rm = lambda : map(int, input().split())
rls = lambda : list(rm())
n = r1()
ans = 0
ans = n // 100
n = n % 100
ans += n // 20
n %= 20
ans += n // 10
n %= 10
ans += n // 5
n %= 5
ans += n
print(ans)


n = int(input())
L = [20, 10, 5, 1]
c = n // 100
n = n % 100
i = 0
while n > 0:
	if n < L[i]:
		i = i + 1
	else:
		n = n - L[i]
		c = c + 1
print(c)


n = input()
n = int(n)
krup = 0
k = 100
while n != 0:
	cup = n // k
	n -= cup * k
	krup += cup
	if k == 100 or k == 5:
		k //= 5
	else:
		k //= 2
print(krup)


nos = int(input())
no = 0
no100 = nos // 100
no += no100
nos -= no100 * 100
while nos >= 20:
	nos -= 20
	no += 1
while nos >= 10:
	nos -= 10
	no += 1
while nos >= 5:
	nos -= 5
	no += 1
while nos >= 1:
	nos -= 1
	no += 1
print(no)


def giveres(n):
	hun = 0
	twen = 0
	ten = 0
	fiv = 0
	if n >= 100:
		hun = n // 100
		n = n - hun * 100
	if n >= 20:
		twen = n // 20
		n = n - twen * 20
	if n >= 10:
		ten = n // 10
		n = n - ten * 10
	if n >= 5:
		fiv = n // 5
		n = n - fiv * 5
	return hun + twen + ten + fiv + n
n = int(input())
print(int(giveres(n)))


from collections import Counter
from math import log, e, inf
t = 1
while t:
	t -= 1
	n = int(input())
	sum = 0
	sum += n // 100
	n %= 100
	sum += n // 20
	n %= 20
	sum += n // 10
	n %= 10
	sum += n // 5
	n %= 5
	sum += n
	print(sum)


def kol_kup(n):
	kol = 0
	l_s = [100, 20, 10, 5, 1]
	for i in l_s:
		kol += n // i
		n -= i * (n // i)
	return kol
print(kol_kup(int(input())))


x = int(input())
b = [100, 20, 10, 5, 1]
z = 0
for i in b:
	z += x // i
	x -= i * (x // i)
print(z)


import sys
input = sys.stdin.readline

def solve():
	money = int(input())
	denoms = [100, 20, 10, 5, 1]
	result = 0
	for coin in denoms:
		if money % coin == 0:
			result += round(money / coin)
			return result
		while money >= coin:
			result += 1
			money -= coin
	return result
print(str(solve()))


n = int(input())
c = 0
sto = n // 100
c = c + sto
n = n % 100
dva = n // 20
c = c + dva
n = n % 20
des = n // 10
c = c + des
n = n % 10
piat = n // 5
c = c + piat
n = n % 5
od = n // 1
c = c + od
print(c)


dollars = int(input())
bills = [100, 20, 10, 5, 1]
count = 0
for bill in bills:
	count += dollars // bill
	dollars %= bill
print(count)


n = int(input())
k = 0
k += n // 100
n -= n // 100 * 100
k += n // 20
n -= n // 20 * 20
k += n // 10
n -= n // 10 * 10
k += n // 5
n -= n // 5 * 5
k += n // 1
n -= n // 1
print(k)


def main():
	amount = int(input())
	bill_denoms = [100, 20, 10, 5, 1]
	num_bills = 0
	for denom in bill_denoms:
		num_bills += amount // denom
		amount = amount % denom
	print(num_bills)
main()


n = int(input())
num = 0
if n >= 100:
	num += n // 100
	n = n % 100
if n >= 20:
	num += n // 20
	n = n % 20
if n >= 10:
	num += n // 10
	n = n % 10
if n >= 5:
	num += n // 5
	n = n % 5
if n != 0:
	num += n
print(num)


import sys

def solve():
	n = int(input())
	ans = 0
	if n >= 100:
		ans += n // 100
		n %= 100
	if n >= 20:
		ans += n // 20
		n %= 20
	if n >= 10:
		ans += n // 10
		n %= 10
	if n >= 5:
		ans += n // 5
		n %= 5
	ans += n
	return ans
ans = solve()
print(ans)


n = int(input())
bills = 0
while n != 0:
	if n >= 100:
		k = n // 100
		bills += k
		n -= k * 100
	elif n >= 20:
		k = n // 20
		bills += k
		n -= k * 20
	elif n >= 10:
		k = n // 10
		bills += k
		n -= k * 10
	elif n >= 5:
		k = n // 5
		bills += k
		n -= k * 5
	elif n >= 1:
		k = n // 1
		bills += k
		n -= k * 1
print(bills)


a = int(input())
c = 0
z = [1, 5, 10, 20, 100][::-1]
for x in z:
	if a >= x:
		c += a // x
		a %= x
print(c)


n = int(input())
l = [100, 20, 10, 5, 1]
count = 0
for x in l:
	if n // x > 0:
		count += n // x
		n = n - n // x * x
if n > 0:
	count += n
print(count)


n = int(input())
m = 0
c = [100, 20, 10, 5, 1]
for each in c:
	a = n % each
	m += n // each
	n = a
print(m)


n = int(input())
t = n
i = 4
su = 0
a = [1, 5, 10, 20, 100]
while t != 0 and i >= 0:
	x = t // a[i]
	t = t - x * a[i]
	su = su + x
	i = i - 1
print(su)


n = int(input())
count = 0
flag = 0
arr = [100, 20, 10, 5, 1]
for x in arr:
	if n > 0:
		count += n // x
		n = n % x
	else:
		break
print(count)


t = int(input())
arr = [100, 20, 10, 5, 1]
bill = 0
i = 0
while True:
	if t == 0:
		break
	if arr[i] <= t:
		t -= arr[i]
		bill += 1
	else:
		i += 1
print(bill)


n = int(input())
cnt = 0
bank = [100, 20, 10, 5, 1]
for x in bank:
	cnt += int(n / x)
	n -= int(n / x) * x
print(cnt)


import math
n = int(input())
sum = 0
sum += math.floor(n / 100)
n %= 100
sum += math.floor(n / 20)
n %= 20
sum += math.floor(n / 10)
n %= 10
sum += math.floor(n / 5)
n %= 5
sum += n
print(sum)


n = int(input())
cnt = 0
if n >= 100:
	cnt += n // 100
	n %= 100
if n >= 20:
	cnt += n // 20
	n %= 20
if n >= 10:
	cnt += n // 10
	n %= 10
if n >= 5:
	cnt += n // 5
	n %= 5
if n >= 1:
	cnt += n // 1
	n %= 1
print(cnt)


t = int(input())
l = [100, 20, 10, 5, 1]
c = 0
for i in l:
	c += t // i
	t = t % i
print(c)


def solve(n):
	ans = 0
	temp = n
	while n != 0:
		bills = [100, 20, 10, 5, 1]
		for b in bills:
			if n >= b:
				n %= b
				ans += (temp - n) / b
				temp = n
				break
	return int(ans)
n = int(input())
print(solve(n))


a = int(input())
dn = [100, 20, 10, 5, 1]
bills = 0
for i in dn:
	while a >= i:
		if a >= i:
			c = int(a / i)
			a -= c * i
			bills += c
print(bills)


a = int(input())
c = 0
h = 0
g = 0
t = 0
r = 0
if a >= 100:
	c = a // 100
	a = a - 100 * c
if a >= 20:
	h = a // 20
	a = a - 20 * h
if a >= 10:
	g = a // 10
	a = a - 10 * g
if a >= 5:
	r = a // 5
	a = a - 5 * r
if a >= 1:
	t = a // 1
	a = a - t
sum = c + h + g + r + t
print(sum)


def main():
	n = int(input())
	n_bills = 0
	bills = [1, 5, 10, 20, 100]
	max_bills = [n // b for b in bills]
	for b in sorted(bills, reverse=True):
		n_bills += n // b
		n -= n // b * b
	print(n_bills)
main()


money = int(input())
bills = [100, 20, 10, 5, 1]
num = 0
for bill in bills:
	num += int(money / bill)
	money = money % bill
	if money == 0:
		print(num)
		break


x = int(input())
a = 0
if x >= 100:
	a += x // 100
	x = x % 100
if x >= 20:
	a = x // 20 + a
	x = x % 20
if x >= 10:
	a += x // 10
	x = x % 10
if x >= 5:
	a += x // 5
	x = x % 5
if x >= 1:
	a += x // 1
print(a)


R = lambda : [*map(int, input().split())]
n = R()
ans = n[0] // 100
n[0] %= 100
ans += n[0] // 20
n[0] %= 20
ans += n[0] // 10
n[0] %= 10
ans += n[0] // 5
n[0] %= 5
ans += n[0]
print(ans)


n = int(input())
notas = [100, 20, 10, 5, 1]
temp = 0
index = 0
while n > 0:
	div = n // notas[index]
	resto = n % notas[index]
	if div > 0:
		n = resto
		temp += div
	else:
		index += 1
print(temp)


a = [100, 20, 10, 5, 1]
b = int(input())
count = 0
for i in a:
	count += b // i
	a = b % i
	b = a
print(count)


n = int(input())
(c, c1) = (n // 100, n % 100)
(d, d1) = (c1 // 20, c1 % 20)
(e, e1) = (d1 // 10, d1 % 10)
(f, f1) = (e1 // 5, e1 % 5)
(g, g1) = (f1 // 1, f1 % 1)
v = c + d + e + f + g
print(v)


n = int(input())
bills = [100, 20, 10, 5, 1]
c = 0
for bill in bills:
	c += n // bill
	n %= bill
print(c)


n = int(input())
f = 0
f += n // 100
f += n % 100 // 20
f += n % 20 // 10
f += n % 10 // 5
f += n % 5 // 1
print(f)


amount = int(input())
notes = [100, 20, 10, 5, 1]
notes_count = [0, 0, 0, 0, 0]
count = 0
for (i, j) in zip(notes, notes_count):
	if amount >= i:
		j = amount // i
		amount = amount - j * i
		count += j
print(count)


n = int(input())
r = 0
for k in [100, 20, 10, 5, 1]:
	r += n // k
	n %= k
print(r)


n = int(input())
count_100 = n // 100
n = n % 100
count_20 = n // 20
n = n % 20
count_10 = n // 10
n = n % 10
count_5 = n // 5
n = n % 5
count_1 = n
count = count_100 + count_20 + count_10 + count_5 + count_1
print(count)


from collections import deque
from collections import Counter
from itertools import permutations
import heapq

def counterExample():
	arr = [1, 3, 4, 1, 2, 1, 1, 3, 4, 3, 5, 1, 2, 5, 3, 4, 5]
	counter = Counter(arr)
	top_three = counter.most_common(3)
	print(top_three)
q = deque()
import math

def main():
	n = int(input())
	bills = [100, 20, 10, 5, 1]
	count = 0
	i = 0
	for bill in bills:
		count = count + n // bill
		n = n % bill
	print(count)
main()


import math

def func():
	p = int(input())
	ans = 0
	if p > 100:
		ans += math.floor(p / 100)
		p -= math.floor(p / 100) * 100
	while p % 5 != 0:
		p -= 1
		ans += 1
	if p % 5 == 0 and p % 10 != 0:
		p -= 5
		ans += 1
	if p % 20 != 0:
		p -= 10
		ans += 1
	ans += int(p / 20)
	print(int(ans))
func()


n = int(input())
k_100 = n // 100
n = n % 100
k_20 = n // 20
n = n % 20
k_10 = n // 10
n = n % 10
k_5 = n // 5
n = n % 5
print(k_100 + k_20 + k_10 + k_5 + n)


import sys
import collections
from collections import Counter
import itertools
import math
import timeit

def sieve(n):
	if n < 2:
		return list()
	prime = [True for _ in range(n + 1)]
	p = 3
	while p * p <= n:
		if prime[p]:
			for i in range(p * 2, n + 1, p):
				prime[i] = False
		p += 2
	r = [2]
	for p in range(3, n + 1, 2):
		if prime[p]:
			r.append(p)
	return r

def divs(n, start=1):
	divisors = []
	for i in range(start, int(math.sqrt(n) + 1)):
		if n % i == 0:
			if n / i == i:
				divisors.append(i)
			else:
				divisors.extend([i, n // i])
	return divisors

def divn(n, primes):
	divs_number = 1
	for i in primes:
		if n == 1:
			return divs_number
		t = 1
		while n % i == 0:
			t += 1
			n //= i
		divs_number *= t

def flin(d, x, default=-1):
	left = right = -1
	for i in range(len(d)):
		if d[i] == x:
			if left == -1:
				left = i
			right = i
	if left == -1:
		return (default, default)
	else:
		return (left, right)

def ceil(n, k):
	return n // k + (n % k != 0)

def ii():
	return int(input())

def mi():
	return map(int, input().split())

def li():
	return list(map(int, input().split()))

def lcm(a, b):
	return abs(a * b) // math.gcd(a, b)

def prr(a, sep=' '):
	print(sep.join(map(str, a)))

def dd():
	return collections.defaultdict(int)
c = [1, 5, 10, 20, 100]
n = ii()
res = 0
for i in c[::-1]:
	res += n // i
	n %= i
print(res)


total_money = int(input())
loop_counter = 0
while total_money != 0:
	if total_money % 100 >= 0:
		loop_counter += (total_money - total_money % 100) / 100
		total_money %= 100
		if total_money % 100 == 0:
			break
	if total_money % 20 >= 0:
		loop_counter += (total_money - total_money % 20) / 20
		total_money %= 20
		if total_money % 20 == 0:
			break
	if total_money % 10 >= 0:
		loop_counter += (total_money - total_money % 10) / 10
		total_money %= 10
		if total_money % 10 == 0:
			break
	if total_money % 5 >= 0:
		loop_counter += (total_money - total_money % 5) / 5
		total_money %= 5
		if total_money % 5 == 0:
			break
	if total_money % 1 >= 0:
		loop_counter = loop_counter + 1
		total_money -= 1
		if total_money == 0:
			break
print(int(loop_counter))


def solve():
	n = int(input())
	count = 0
	denom = [1, 5, 10, 20, 100]
	if n in denom:
		print(1)
		return
	for elem in reversed(denom):
		if n >= elem:
			count += n // elem
			n = n % elem
		if n == 0:
			break
	print(count)
solve()


money = int(input())
diff = 0
diff = money - diff
unit = [1, 5, 10, 20, 100]
results = 0
unitI = 4
while diff != 0:
	results += diff // unit[unitI]
	diff -= diff // unit[unitI] * unit[unitI]
	unitI -= 1
print(results)


n = int(input())
bills = 0
denoms = [100, 20, 10, 5, 1]
for d in denoms:
	if n >= d:
		bills += n // d
		n = n % d
print(bills)


N = int(input())
co = 0
if N >= 100:
	N1 = N // 100
	co = co + N1
	N = N % 100
if N < 100 and N >= 20:
	N1 = N // 20
	co = co + N1
	N = N % 20
if N < 20 and N >= 10:
	N1 = N // 10
	co = co + N1
	N = N % 10
if N < 10 and N >= 5:
	N1 = N // 5
	co = co + N1
	N = N % 5
if N < 5 and N >= 1:
	N1 = N // 1
	co = co + N1
	N = N % 1
print(co)


a = int(input())
b = a
t = 0
q = 0
t = t + a // 100
a = a % 100
t = t + a // 20
a = a % 20
t = t + a // 10
a = a % 10
t = t + a // 5
a = a % 5
t = t + a // 1
print(t)


n = int(input())
den = [1, 5, 10, 20, 100]
c = 0
while n != 0:
	mx = 0
	for i in den:
		if i >= mx and i <= n:
			mx = i
			d = n // i
	c = c + d
	n = n - mx * d
print(c)


n = int(input())
dollars = [100, 20, 10, 5, 1]
l = 0
for i in dollars:
	if n >= i:
		num = n // i
		n = n - num * i
		l += num
print(l)


import sys
import os
from math import sqrt, log, log2, log10, gcd, floor, pow, sin, cos, tan, pi, inf, factorial
from copy import copy, deepcopy
from sys import exit, stdin, stdout
from collections import Counter, defaultdict, deque
from itertools import permutations
import heapq
from bisect import bisect_left as bl
from bisect import bisect_right as br
from bisect import bisect
mod = 1000000007
iinp = lambda : int(sys.stdin.readline())
inp = lambda : sys.stdin.readline().strip()
strl = lambda : list(inp().strip().split(' '))
intl = lambda : list(map(int, inp().split(' ')))
mint = lambda : map(int, inp().split())
flol = lambda : list(map(float, inp().split(' ')))
flush = lambda : stdout.flush()

def isPrime(n):
	if n <= 1:
		return False
	if n <= 3:
		return True
	if n % 2 == 0 or n % 3 == 0:
		return False
	p = int(sqrt(n))
	for i in range(5, p + 1, 6):
		if n % i == 0 or n % (i + 2) == 0:
			return False
	return True

def solve():
	n = iinp()
	ans = 0
	ans += n // 100
	n %= 100
	ans += n // 20
	n %= 20
	ans += n // 10
	n %= 10
	ans += n // 5
	n %= 5
	ans += n
	print(ans)
solve()


n = int(input())
l = [100, 20, 10, 5, 1]
c = 0
for i in l:
	if n == 0:
		break
	elif i <= n:
		x = n // i
		n = n % i
		c += x
print(c)


n = int(input())
bill = [100, 20, 10, 5, 1]

def cash(n):
	pieces = 0
	i = 0
	while n != 0:
		pieces += n // bill[i]
		n -= n // bill[i] * bill[i]
		i += 1
	print(pieces)
cash(n)


a = int(input())
count = 0
while a >= 100:
	a -= 100
	count += 1
while a >= 20:
	a -= 20
	count += 1
while a >= 10:
	a -= 10
	count += 1
while a >= 5:
	a -= 5
	count += 1
while a >= 1:
	a -= 1
	count += 1
print(count)


n = int(input())
cnt = 0
while n != 0:
	for amt in [100, 20, 10, 5, 1]:
		if amt <= n:
			divs = n // amt
			cnt += divs
			n -= amt * divs
			break
print(cnt)


n = int(input())
coin_count = 0
for coin in [100, 20, 10, 5, 1]:
	coin_count += n // coin
	n = n % coin
print(coin_count)


mon = int(input())
x = 0
y = 0
z = 0
p = 0
q = 0
while mon > 0:
	if mon >= 100:
		x = int(mon / 100)
		mon -= x * 100
	elif 20 <= mon < 100:
		y = int(mon / 20)
		mon -= y * 20
	elif 10 <= mon < 20:
		z = int(mon / 10)
		mon -= z * 10
	elif 5 <= mon < 10:
		p = int(mon / 5)
		mon -= p * 5
	else:
		q = mon
		mon = 0
print(x + y + z + p + q)


bills = [100, 20, 10, 5, 1]

def min_num_bills(n):
	count = 0
	left = n
	for bill in bills:
		count += left // bill
		left = left % bill
	return count
n = int(input())
print(min_num_bills(n))


n = int(input())
denoms = [100, 20, 10, 5, 1]
count = 0
x = 0
while x <= 4:
	if n - denoms[x] >= 0:
		count += 1
		n -= denoms[x]
	else:
		x += 1
print(count)


x = int(input())
output = x / 100
rest = x % 100
input2 = rest / 20
rest2 = rest % 20
input3 = rest2 / 10
rest3 = rest2 % 10
input4 = rest3 / 5
rest4 = rest3 % 5
input5 = rest4 / 1
if rest is 0:
	print(int(output))
elif rest2 is 0:
	print(int(input2) + int(output))
elif rest3 is 0:
	print(int(input2) + int(output) + int(input3))
elif rest4 is 0:
	print(int(input2) + int(output) + int(input3) + int(input4))
elif input5:
	print(int(input2) + int(output) + int(input3) + int(input4) + int(input5))


x = int(input())
count = 0
while x != 0:
	if x >= 100:
		r = x // 100
		x = x % 100
		count += r
	elif x >= 20:
		r = x // 20
		x = x % 20
		count += r
	elif x >= 10:
		r = x // 10
		x = x % 10
		count += r
	elif x >= 5:
		r = x // 5
		x = x % 5
		count += r
	else:
		count += x
		x -= x
print(count)


class CodeforcesTask996ASolution:

	def __init__(self):
		self.result = ''
		self.n = 0

	def read_input(self):
		self.n = int(input())

	def process_task(self):
		coins = [100, 20, 10, 5, 1]
		used = 0
		while self.n:
			coin = coins.pop(0)
			used += self.n // coin
			self.n = self.n % coin
		self.result = str(used)

	def get_result(self):
		return self.result
Solution = CodeforcesTask996ASolution()
Solution.read_input()
Solution.process_task()
print(Solution.get_result())


n = int(input())
ans = 0
if n >= 100:
	x = n // 100
	ans += x
	n -= x * 100
if n >= 20:
	x = n // 20
	ans += x
	n -= x * 20
if n >= 10:
	x = n // 10
	ans += x
	n -= x * 10
if n >= 5:
	x = n // 5
	ans += x
	n -= x * 5
if n >= 1:
	x = n // 1
	ans += x
	n -= x * 1
print(ans)


money = int(input())
count = 0
listdenom = [100, 20, 10, 5, 1]
for i in listdenom:
	maxnumofdenom = money // i
	count = count + maxnumofdenom
	money = money - maxnumofdenom * i
print(count)


i = int(input())
res = 0
res += i // 100
i %= 100
res += i // 20
i %= 20
res += i // 10
i %= 10
res += i // 5
i %= 5
res += i
print(res)


n = int(input())
nominals = [100, 20, 10, 5, 1]
res = 0
for nom in nominals:
	res += n // nom
	n = n % nom
	if n == 0:
		break
print(res)


cash = int(input())
bills = 0
while cash >= 100:
	bills += cash // 100
	cash %= 100
while cash >= 20:
	bills += cash // 20
	cash %= 20
while cash >= 10:
	bills += cash // 10
	cash %= 10
while cash >= 5:
	bills += cash // 5
	cash %= 5
while cash > 0:
	bills += 1
	cash -= 1
print(bills)


balance = int(input())
notas = [100, 20, 10, 5, 1]
celulas = 0
index = 0
while balance > 0:
	divisao = balance // notas[index]
	resto = balance % notas[index]
	if divisao > 0:
		balance = resto
		celulas += divisao
	else:
		index += 1
print(celulas)


cash = int(input())
bills = 0
while cash > 0:
	if cash >= 100:
		bills += cash // 100
		cash -= 100 * (cash // 100)
	elif cash >= 20:
		bills += cash // 20
		cash -= 20 * (cash // 20)
	elif cash >= 10:
		bills += cash // 10
		cash -= 10 * (cash // 10)
	elif cash >= 5:
		bills += cash // 5
		cash -= 5 * (cash // 5)
	else:
		bills += cash
		cash -= cash
print(bills)


n = int(input())
i = 0
l = [100, 20, 10, 5, 1]
for el in l:
	if n >= el:
		i += n // el
		n = n % el
print(i)


n = int(input())
f = 0
while n > 0:
	if n >= 100:
		e = n // 100
		f = f + e
		n = n - 100 * e
	if n >= 20:
		e = n // 20
		f = f + e
		n = n - 20 * e
	if n >= 10:
		e = n // 10
		f = f + e
		n = n - 10 * e
	if n >= 5:
		e = n // 5
		f = f + e
		n = n - 5 * e
	if n >= 1:
		e = n // 1
		f = f + e
		n = n - 1 * e
	if n == 0:
		break
print(f)


x = int(input())
m = x // 100
n = x % 100 // 20
o = x % 20 // 10
p = x % 10 // 5
q = x % 5 // 1
sum = m + n + o + p + q
print(sum)


def main():
	n = int(input().strip())
	denoms = [1, 5, 10, 20, 100]
	sorted_denoms = sorted(denoms, reverse=True)
	count = 0
	count = n // sorted_denoms[0]
	n = n % sorted_denoms[0]
	for (i, denom) in enumerate(sorted_denoms):
		if i == 0:
			continue
		count += n // denom
		n = n % denom
	print(count)
main()


n = int(input())
nums = [100, 20, 10, 5, 1]
result = 0
for i in range(5):
	result += n // nums[i]
	n = n % nums[i]
print(result)


n = int(input())
num100 = n // 100
rem100 = n % 100
num20 = rem100 // 20
rem20 = rem100 % 20
num10 = rem20 // 10
rem10 = rem20 % 10
num5 = rem10 // 5
num1 = rem10 % 5
print(num100 + num20 + num10 + num5 + num1)


cash = input()
bills = 0
x1 = int(cash[len(cash) - 1])
while x1 != 0:
	if x1 >= 5:
		x1 -= 5
		bills += 1
	elif x1 >= 1:
		x1 -= 1
		bills += 1
x2 = int(cash[len(cash) - 2] + '0')
while x2 != 0 and len(cash) - 2 >= 0:
	if x2 >= 20:
		x2 -= 20
		bills += 1
	elif x2 >= 10:
		x2 -= 10
		bills += 1
x3 = int(cash[:len(cash) - 2] + '00')
bills += x3 // 100
print(bills)


n = int(input())
d = 0
if n > 0:
	d += n // 100
	n %= 100
if n > 0:
	d += n // 20
	n %= 20
if n > 0:
	d += n // 10
	n %= 10
if n > 0:
	d += n // 5
	n %= 5
if n > 0:
	d += n
print(d)


import sys
bills = [100, 20, 10, 5, 1]
n = int(input())
i = 0
count = 0
while n > 0:
	if n - bills[i] >= 0:
		n = n - bills[i]
		count += 1
	elif i == 4:
		i = 4
	else:
		i += 1
print(count)


denom = [100, 20, 10, 5, 1]
dp = {0: 0}

def maxBillLessThan(n):
	for bill in denom:
		if n > bill:
			return bill

def min_bills(n):
	if n in dp:
		return dp[n]
	lessThan = [bill for bill in denom if n >= bill]
	minValues = list(map(lambda bill: min_bills(n - bill), lessThan))
	minBill = maxBillLessThan(n)
	dp[n] = 1 + min(minValues)
	return dp[n]
n = int(input())
hundred_bills = n / 100
print(int(hundred_bills + min_bills(n % 100)))


n = int(input())
den = [100, 20, 10, 5, 1]
i = 0
bills = 0
while n > 0:
	t = n // den[i]
	if t > 0:
		bills += t
		n %= den[i]
	i += 1
print(bills)


a = int(input())
(a1, a2, a3, a4) = (0, 0, 0, 0)
if a >= 100:
	a1 = a // 100
a = a - a1 * 100
if a >= 20:
	a2 = a // 20
a = a - a2 * 20
if a >= 10:
	a3 = a // 10
a = a - a3 * 10
if a >= 5:
	a4 = a // 5
a = a - a4 * 5
print(a1 + a2 + a3 + a4 + a)


bills = 0
amount = int(input().strip())
dn = [100, 20, 10, 5, 1]
for v in dn:
	if amount % v >= 0 and amount > 0:
		notes = amount // v
		bills += notes
		amount -= notes * v
print(bills)


c = int(input())
print(c // 100 + c % 100 // 20 + c % 20 // 10 + c % 10 // 5 + c % 5)


t = int(input())
num_of_bill = 0
if t >= 100:
	dif = t - t % 100
	num_of_bill += dif // 100
	t -= dif
if t >= 20:
	dif = t - t % 20
	num_of_bill += dif // 20
	t -= dif
if t >= 10:
	dif = t - t % 10
	num_of_bill += dif // 10
	t -= dif
if t >= 5:
	dif = t - t % 5
	num_of_bill += dif // 5
	t -= dif
if t >= 1:
	dif = t - t % 1
	num_of_bill += dif // 1
	t -= dif
print(num_of_bill)


ans = 0
bal = int(input())
a = [100, 20, 10, 5, 1]
for i in a:
	ans += bal // i
	bal = bal - bal // i * i
print(ans)


n = int(input())
ans = 0
(a, b) = divmod(n, 100)
ans += a
(a, b) = divmod(b, 20)
ans += a
(a, b) = divmod(b, 10)
ans += a
(a, b) = divmod(b, 5)
ans += a
(a, b) = divmod(b, 1)
ans += a
print(ans)


def min_bills(money):
	count = 0
	if money // 100:
		count += money // 100
		if money // 100 * count == money:
			return count
	string = str(money)
	if len(string) > 1:
		decenas = string[-2]
		decenasint = int(decenas)
		count += decenasint // 2 + decenasint % 2
	unidades = string[-1]
	unidadesint = int(unidades)
	count += unidadesint // 5 + unidadesint % 5
	return count
money = int(input())
print(min_bills(money))


def read_int() -> int:
	return int(input())
value = read_int()
dollar_bills = [1, 5, 10, 20, 100]
result = 0
idx_bill = 4
while value != 0:
	if value >= dollar_bills[idx_bill]:
		result += value // dollar_bills[idx_bill]
		value = value % dollar_bills[idx_bill]
	else:
		idx_bill -= 1
print(result)


def domination(n):
	notes = [100, 20, 10, 5, 1]
	count = 0
	for i in notes:
		if n != 0:
			count = count + n // i
			n = n - i * (n // i)
		else:
			break
	return count
n = int(input())
print(domination(n))


n = int(input())
ans = 0
while n > 0:
	if n >= 100:
		n -= 100
	elif n >= 20 and n < 100:
		n -= 20
	elif n >= 10 and n < 20:
		n -= 10
	elif n >= 5 and n < 10:
		n -= 5
	else:
		n -= 1
	ans += 1
print(ans)


n = int(input())
notes = 0
for d in [100, 20, 10, 5, 1]:
	notes += n // d
	n = n % d
print(notes)


n = int(input())
t = [1, 5, 10, 20, 100]
x = 0
w = 0
while n > 0:
	if n >= 1000:
		w = n // 100
		n = n - w * 100
		x = x + w
	elif n >= 100:
		n = n - 100
		x = x + 1
	elif n >= 20:
		n = n - 20
		x = x + 1
	elif n >= 10:
		n = n - 10
		x = x + 1
	elif n >= 5:
		n = n - 5
		x = x + 1
	elif n >= 1:
		n = n - 1
		x = x + 1
print(x)


a = int(input())
b = a // 100
a -= b * 100
b += a // 20
a -= a // 20 * 20
b += a // 10
a -= a // 10 * 10
b += a // 5
a -= a // 5 * 5
b += a // 1
print(b)


amount = int(input())
counter = 0
dollars = 0
if amount >= 100:
	dollars += amount // 100
	amount %= 100
if amount >= 20:
	dollars += amount // 20
	amount %= 20
if amount >= 10:
	dollars += amount // 10
	amount %= 10
if amount >= 5:
	dollars += amount // 5
	amount %= 5
if amount >= 1:
	dollars += amount // 1
	amount %= 1
print(dollars)


amt = int(input())
count = 0
while amt > 0:
	if amt >= 100:
		count += amt // 100
		amt = amt % 100
	elif amt >= 20:
		count += amt // 20
		amt = amt % 20
	elif amt >= 10:
		count += amt // 10
		amt = amt % 10
	elif amt >= 5:
		count += amt // 5
		amt = amt % 5
	else:
		count += amt
		amt = 0
print(count)


money = int(input())
bills = [100, 20, 10, 5, 1]
num = 0
for i in bills:
	num += int(money / i)
	money = money % i
print(num)


def main(n):
	bills = 0
	while n >= 1:
		if n >= 100:
			x = n // 100
			n -= x * 100
			bills += x
		if 100 > n >= 20:
			x = n // 20
			n -= x * 20
			bills += x
		if 20 > n >= 10:
			x = n // 10
			n -= 10 * x
			bills += x
		if 10 > n >= 5:
			x = n // 5
			n -= 5 * x
			bills += x
		if 5 > n >= 1:
			bills += n
			n = 0
	return bills
x = input()
print(main(int(x)))


import sys
n = int(sys.stdin.readline())
bills = [100, 20, 10, 5, 1]
nbills = 0
for i in range(5):
	amount = n // bills[i]
	nbills += amount
	n -= amount * bills[i]
	if n == 0:
		break
print(nbills)


num = int(input())
bills = 0
flags = [1, 5, 10, 20, 100]
while True:
	flag = flags.pop()
	if flag == 1:
		break
	count = int(num / flag)
	bills += count
	num -= flag * count
bills += num
print(bills)


bills = [100, 20, 10, 5, 1]
money = int(input())
bills_from_money = 0
for bill in bills:
	bills_from_money += money // bill
	money = money % bill
print(bills_from_money)


a = int(input())
l = [100, 20, 10, 5, 1]
v = [0, 0, 0, 0, 0]
for i in range(len(l)):
	while a >= l[i]:
		x = a // l[i]
		a -= l[i] * x
		v[i] += x
print(sum(v))


n = int(input())
hundreds = n // 100
n = n - hundreds * 100
twenties = n // 20
n = n - twenties * 20
tens = n // 10
n = n - tens * 10
fives = n // 5
n = n - fives * 5
ones = n // 1
total = hundreds + twenties + tens + fives + ones
print(total)


n = int(input())
res = 0
for bill in [100, 20, 10, 5, 1]:
	(d, r) = divmod(n, bill)
	res += d
	n = r
print(res)


n = int(input())
arr = [1, 5, 10, 20, 100]
arr.reverse()
ans = []
i = 0
while i < len(arr):
	while n >= arr[i]:
		n -= arr[i]
		ans.append(arr[i])
	i += 1
print(len(ans))


n = int(input())
count = 0
some = True
while some:
	if n >= 100:
		count += n // 100
		n = n % 100
	elif n >= 20:
		count += n // 20
		n = n % 20
	elif n >= 10:
		count += n // 10
		n = n % 10
	elif n >= 5:
		count += n // 5
		n = n % 5
	elif n >= 1:
		count += n
		break
	else:
		break
print(count)


nom = [100, 20, 10, 5, 1]
n = int(input())
sum = 0
for i in nom:
	sum += int(n / i)
	n = n - i * int(n / i)
print(sum)


n = int(input())
coins = [1, 5, 10, 20, 100]
count = 0
for coin in reversed(coins):
	(quot, rem) = divmod(n, coin)
	count += quot
	n = rem
print(count)


(n, ans) = (int(input()), 0)
while n > 0:
	if n >= 100:
		pocet = n // 100
		n -= pocet * 100
		ans += pocet
	elif n >= 20:
		pocet = n // 20
		n -= pocet * 20
		ans += pocet
	elif n >= 10:
		pocet = n // 10
		n -= pocet * 10
		ans += pocet
	elif n >= 5:
		pocet = n // 5
		n -= pocet * 5
		ans += pocet
	else:
		ans += n
		n = 0
print(ans)


n = int(input())
min_bills = 0
while n > 0:
	if n >= 100:
		min_bills += n // 100
		n = n % 100
	elif n < 100 and n >= 20:
		min_bills += n // 20
		n = n % 20
	elif n >= 10 and n < 20:
		min_bills += n // 10
		n = n % 10
	elif n < 10 and n >= 5:
		min_bills += n // 5
		n = n % 5
	else:
		min_bills += n
		n = 0
print(min_bills)


money = int(input())
notes = [100, 20, 10, 5, 1]
cnt = int(0)
for n in notes:
	cnt = cnt + int(money / n)
	money = money % n
print(cnt)


n = int(input(''))
sol = 0
sol += n // 100
n = n % 100
sol += n // 20
n = n % 20
sol += n // 10
n = n % 10
sol += n // 5
n = n % 5
sol += n
print(sol)


def hit(n, deno):
	count = 0
	for i in range(len(deno)):
		while n >= deno[i]:
			n = n - deno[i]
			count += 1
	print(count)
n = int(input())
deno = [100, 20, 10, 5, 1]
hit(n, deno)


x = int(input())
a = int(x / 100)
x = x - a * 100
b = int(x / 20)
x = x - b * 20
c = int(x / 10)
x = x - c * 10
d = int(x / 5)
x = x - d * 5
print(a + b + c + d + x)


n = int(input())
a = n // 100
r = n % 100
c = r // 20
r = r % 20
d = r // 10
r = r % 10
e = r // 5
r = r % 5
f = r
print(a + c + d + e + f)


x = [1, 5, 10, 20, 100]
y = int(input())
ctr = 4
answer = 0
while y > 0:
	while y // x[ctr] == 0 and ctr > 0:
		ctr -= 1
	answer += y // x[ctr]
	y -= y // x[ctr] * x[ctr]
print(answer)


cash = int(input())
sizes = [100, 20, 10, 5, 1]
count = 0
for size in sizes:
	nums = int(cash / size)
	count += nums
	cash -= nums * size
print(count)


import sys
input = lambda : sys.stdin.readline().rstrip()
n = int(input())
a = [100, 20, 10, 5, 1]
ans = 0
for i in a:
	ans += n // i
	n = n % i
print(ans)


def reduce_function(total, v, n):
	if total >= v:
		n += total // v
		count = total // v
		total = total % v
	if total > 0 and v == 1:
		n += total
		total = 0
	return [total, n]
total = int(input())
n = 0
bills = [100, 20, 10, 5, 1]
while bills and total > 0:
	output = reduce_function(total, bills.pop(0), 0)
	total = output[0]
	n += output[1]
print(n)


money = [1, 5, 10, 20, 100]
n = int(input())
ans = 0
for i in range(4, -1, -1):
	div = n // money[i]
	ans += div
	n -= div * money[i]
print(ans)


stri = str(input())
a = [int(s) for s in stri.split() if s.isdigit()]
n = a[0]
coup = 0
while n > 0:
	if n - 100 >= 0:
		coup += n // 100
		n -= 100 * (n // 100)
	elif n - 20 >= 0:
		n -= 20
		coup += 1
	elif n - 10 >= 0:
		n -= 10
		coup += 1
	elif n - 5 >= 0:
		n -= 5
		coup += 1
	elif n - 1 >= 0:
		coup += n
		break
print(coup)


n = int(input())
sm = 0
sm += n // 100
sm += n % 100 // 20
sm += n % 100 % 20 // 10
sm += n % 100 % 20 % 10 // 5
sm += n % 100 % 20 % 10 % 5
print(sm)


m = int(input())

def coins(m, min):
	if m <= 0:
		return min
	c = 0
	if m >= 100:
		c = int(m / 100)
		min += c
		m = m - c * 100
		return coins(m, min)
	elif m < 100 and m >= 20:
		c = int(m / 20)
		min += c
		m = m - c * 20
		return coins(m, min)
	elif m < 20 and m >= 10:
		c = int(m / 10)
		min += c
		m = m - c * 10
		return coins(m, min)
	elif m < 10 and m >= 5:
		c = int(m / 5)
		min += c
		m = m - c * 5
		return coins(m, min)
	elif m < 5 and m > 0:
		min += m
		return min
print(coins(m, 0))


n = int(input())
ans = 0
for val in (100, 20, 10, 5):
	ans += n // val
	n = n % val
print(ans + n)


n = int(input())
col = 0
col100 = n // 100
col = col + col100
n = n - col100 * 100
col20 = n // 20
col = col + col20
n = n - col20 * 20
col10 = n // 10
col = col + col10
n = n - col10 * 10
col5 = n // 5
col = col + col5
n = n - col5 * 5
col = col + n
print(col)


t = int(input())
d = [100, 20, 10, 5, 1]
(c, i) = (0, 0)
while t:
	if t >= d[i]:
		c = c + t // d[i]
		t = t % d[i]
	else:
		i = i + 1
print(c)


n = int(input())
res = 0
l = [100, 20, 10, 5, 1]
while n:
	for i in l:
		if i <= n:
			res += n // i
			n = n % i
			break
print(res)


n = int(input())
remaining_money = n
count = 0
hundred_bills = int(n / 100)
remaining_money = n - hundred_bills * 100
count = count + hundred_bills
twenty_bills = int(remaining_money / 20)
remaining_money = remaining_money - twenty_bills * 20
count = count + twenty_bills
ten_bills = int(remaining_money / 10)
remaining_money = remaining_money - ten_bills * 10
count = count + ten_bills
five_bills = int(remaining_money / 5)
remaining_money = remaining_money - five_bills * 5
count = count + five_bills
count = count + remaining_money
print(count)


m = int(input())
h = m // 100
tw = (m - h * 100) // 20
te = (m - h * 100 - tw * 20) // 10
f = (m - h * 100 - tw * 20 - te * 10) // 5
o = m - h * 100 - tw * 20 - te * 10 - f * 5
print(h + tw + te + f + o)


n = int(input())
cnt_100 = n // 100
n = n % 100
cnt_20 = n // 20
n = n % 20
cnt_10 = n // 10
n = n % 10
cnt_5 = n // 5
n = n % 5
print(cnt_100 + cnt_20 + cnt_10 + cnt_5 + n)


a = int(input())
money = [100, 20, 10, 5, 1]
moneyleft = a
counter = 0
for bill in money:
	if not moneyleft:
		break
	numberofbills = moneyleft // bill
	counter += numberofbills
	moneyleft = moneyleft - numberofbills * bill
print(counter)


n = int(input())
r = 0
while n >= 5:
	if n >= 100:
		r += int(n / 100)
		n = int(n % 100)
	elif n < 100 and n >= 20:
		r += int(n / 20)
		n = n % 20
	elif n < 20 and n >= 10:
		r += int(n / 10)
		n = n % 10
	elif n < 10 and n >= 5:
		r += int(n / 5)
		n = n % 5
print(n + r)


n = int(input())
s = 0
a100 = n // 100
s = s + a100
n = n - a100 * 100
a20 = n // 20
n = n - a20 * 20
a10 = n // 10
n = n - a10 * 10
a5 = n // 5
n = n - a5 * 5
print(n + a100 + a20 + a10 + a5)


n = int(input())
cup = 0
nom = [100, 20, 10, 5, 1]
for el in nom:
	ccup = n // el
	cup += ccup
	n -= ccup * el
print(cup)


money = int(input())
notes = money // 100
money = money % 100
notes = notes + money // 20
money = money % 20
notes = notes + money // 10
money = money % 10
notes = notes + money // 5
money = money % 5
notes = notes + money
print(notes)


n = int(input())
s = 0
a = n // 100
s += a
b = n % 100 // 20
s += b
c = n % 100 % 20 // 10
s += c
d = n % 100 % 20 % 10 // 5
s += d
s += n % 100 % 20 % 10 % 5 // 1
print(s)


n = int(input())
taglio = [100, 20, 10, 5, 1]
k = 0
for t in taglio:
	k += int(n / t)
	n = n % t
print(k)


n = int(input())
s = [100, 20, 10, 5, 1]
f = 0
for i in range(5):
	f += n // s[i]
	n = n % s[i]
print(f)


a = int(input())
b = a // 100
c = a - b * 100
d = c // 20
e = c - d * 20
f = e // 10
g = e - f * 10
h = g // 5
i = g - h * 5
k = b + d + f + h + i
print(k)


from sys import stdin
nums = [100, 20, 10, 5, 1]
n = int(stdin.readline())
ans = 0
for i in range(5):
	if n >= nums[i]:
		ans += n // nums[i]
		n %= nums[i]
print(ans)


n = int(input())
d = 0
d += n // 100
n = n % 100
d += n // 20
n = n % 20
d += n // 10
n = n % 10
d += n // 5
n = n % 5
d += n // 1
print(d)


N = input()
new = int(N)
total = 0
while new > 0:
	if new % 100 == 0:
		total = total + new / 100
		new = new % 100
	elif new % 20 == 0:
		total = total + 1
		new = new - 20
	elif new % 10 == 0:
		total = total + 1
		new = new - 10
	elif new % 5 == 0:
		total = total + 1
		new = new - 5
	else:
		new = new - 1
		total += 1
print(int(total))


151020100
n = int(input())
c = n // 100
n = n % 100
c += n // 20
n = n % 20
c += n // 10
n = n % 10
c += n // 5
n = n % 5
c += n
print(c)


import time
n = int(input())
c = [100, 20, 10, 5, 1]
i = 0
while n != 0:
	for j in c:
		if n - j >= 0:
			n = n - j
			break
	i += 1
print(i)


bill = [100, 20, 10, 5, 1]
x = int(input())
count = 0
for item in bill:
	count += x // item
	x = x - item * (x // item)
print(count)


novcanice = [100, 20, 10, 5, 1]
n = int(input())
br = 0
for val in novcanice:
	br += n // val
	n = n % val
print(br)


N = int(input())
BillCount = []
Count = 0
Temp = N
if Temp >= 100:
	BillCount.append(int(Temp / 100))
	Count = int(Temp / 100)
	Temp = Temp - Count * 100
if Temp >= 20:
	BillCount.append(int(Temp / 20))
	Count = int(Temp / 20)
	Temp = Temp - Count * 20
if Temp >= 10:
	BillCount.append(int(Temp / 10))
	Count = int(Temp / 10)
	Temp = Temp - Count * 10
if Temp >= 5:
	BillCount.append(int(Temp / 5))
	Count = int(Temp / 5)
	Temp = Temp - Count * 5
if Temp >= 1:
	BillCount.append(Temp)
print(sum(BillCount))


n = int(input())
num = 0

def div(x):
	return n // x
(a, b, c, d, e) = map(div, [1, 5, 10, 20, 100])
print(e + d - e * 5 + c - d * 2 + b - c * 2 + a - b * 5)


def change(D, n, money):
	if money == 0:
		return 0
	elif n == -1:
		return 1000000000
	elif n >= 0:
		return min(change(D, n - 1, money), change(D, n - 1, money % D[n]) + int(money / D[n]))
denominations = [1, 5, 10, 20, 100]
money = int(input())
print(change(denominations, len(denominations) - 1, money))


import math

def main():
	n = int(input())
	bills = {100: 0, 20: 0, 10: 0, 5: 0, 1: 0}
	for bill in bills:
		bills[bill] = math.floor(n / bill)
		n = n % bill
	n_bills = sum(bills.values())
	print(n_bills)
main()


n = int(input())
denom = [100, 20, 10, 5, 1]
rest = n
count = 0
for i in denom:
	count += rest // i
	temp = rest // i
	if rest // i != 0:
		rest -= temp * i
print(count)


din = int(input())
i = 0
lista = [100, 20, 10, 5, 1]
cont = 0
while din != 0:
	cont += din // lista[i]
	din = din % lista[i]
	i += 1
print(cont)


n = int(input())
b = [100, 20, 10, 5, 1]
ans = 0
for (i, v) in enumerate(b):
	ans += n // v
	n -= v * (n // v)
print(ans)


Changes = (100, 20, 10, 5, 1)

def func(money):
	minCoin = 0
	for i in range(len(Changes)):
		minCoin += money // Changes[i]
		money %= Changes[i]
	return minCoin
print(func(int(input())))


x = eval(input())
c = 0
while x != 0:
	if x >= 100:
		c = c + x // 100
		x %= 100
	elif x >= 20:
		x -= 20
		c += 1
	elif x >= 10:
		x -= 10
		c += 1
	elif x >= 5:
		x -= 5
		c += 1
	elif x >= 1:
		x -= 1
		c += 1
print(c)


def cash(x):
	global lll
	l = [1, 5, 10, 20, 100]
	ll = []
	if x == 0:
		return
	else:
		for i in l:
			if i <= x:
				ll.append(i)
		m = max(ll)
		lll += 1
		cash(x - m)
lll = 0
n = int(input())
lll += int(n / 100)
m = n % 100
cash(m)
print(lll)


n = int(input())
res = 0
while True:
	if n == 0:
		break
	if n >= 100:
		res += n // 100
		n = n % 100
	elif n >= 20:
		res += n // 20
		n = n % 20
	elif n >= 10:
		res += n // 10
		n = n % 10
	elif n >= 5:
		res += n // 5
		n = n % 5
	else:
		res += 1
		n -= 1
print(res)


cash = int(input())
no_bills = 0
bills = [100, 20, 10, 5, 1]
for bill in bills:
	no_bills += cash // bill
	cash -= bill * (cash // bill)
print(no_bills)


a = int(input())
s = []
while True:
	if a == 0:
		break
	if len(str(a)) >= 3:
		out = a // 100
		s.append(out)
		a = abs(out * 100 - a)
	if len(str(a)) == 2:
		if a >= 20:
			out = a // 20
			s.append(out)
			a = abs(out * 20 - a)
		if a >= 10 and a < 20:
			out = a // 10
			s.append(out)
			a = abs(out * 10 - a)
	if len(str(a)) == 1:
		if a >= 5:
			out = a // 5
			s.append(out)
			a = abs(out * 5 - a)
		if a < 5:
			out = a // 1
			s.append(out)
			a = abs(out * 1 - a)
print(sum(s))


f = [100, 20, 10, 5, 1]
x = int(input())
s = 0
for y in f:
	s = s + x // y
	x = x % y
print(s)


n = int(input())
t = 0
t += n // 100
n %= 100
t += n // 20
n %= 20
t += n // 10
n %= 10
t += n // 5
n %= 5
t += n
print(t)


d = int(input())
r = 0
while d > 0:
	if d >= 100:
		d = d - 100
	elif d >= 20:
		d = d - 20
	elif d >= 10:
		d = d - 10
	elif d >= 5:
		d = d - 5
	else:
		d = d - 1
	r = r + 1
print(r)


N = int(input())
(note100, note20, note10, note5, note1) = [0, 0, 0, 0, 0]
if N >= 100:
	note100 = N // 100
	N -= note100 * 100
if N >= 20:
	note20 = N // 20
	N -= note20 * 20
if N >= 10:
	note10 = N // 10
	N -= note10 * 10
if N >= 5:
	note5 = N // 5
	N -= note5 * 5
if N >= 1:
	note1 = N
print(note100 + note20 + note10 + note5 + note1)


n = int(input())
sol = 0
if n >= 100:
	sol = sol + n // 100
	n = n % 100
if n >= 20:
	sol = sol + n // 20
	n = n % 20
if n >= 10:
	sol = sol + n // 10
	n = n % 10
if n >= 5:
	sol = sol + n // 5
	n = n % 5
if n >= 1:
	sol = sol + n // 1
	n = n % 1
print(sol)


n = int(input())
l = [100, 20, 10, 5, 1]
c = 0
for i in l:
	while n >= i and n != 0:
		t = n // i
		n = n % i
		c = c + t
print(c)


n = int(input())
l = [1, 5, 10, 20, 100]
l.reverse()
s = 0
i = 0
while n > 0:
	c = n // l[i]
	n -= c * l[i]
	s += c
	i += 1
print(s)


from sys import stdin, stdout
n = int(stdin.readline())
hu = tw = te = fi = one = 0
while n != 0:
	if n >= 100:
		hu = n // 100
		n %= 100
	elif n >= 20:
		tw = n // 20
		n %= 20
	elif n >= 10:
		te = n // 10
		n %= 10
	elif n >= 5:
		fi = n // 5
		n %= 5
	else:
		one = n // 1
		n %= 1
stdout.write(str(hu + tw + te + fi + one))


n = int(input())
bills = 0
if n >= 100:
	bill = n // 100
	bills += bill
	n -= 100 * bill
if n < 100 and n >= 20:
	bill = n // 20
	bills += bill
	n -= 20 * bill
if n < 20 and n >= 10:
	bill = n // 10
	bills += bill
	n -= 10 * bill
if n < 10 and n >= 5:
	bill = n // 5
	bills += bill
	n -= 5 * bill
if n < 5 and n >= 1:
	bill = n // 1
	bills += bill
	n -= 1 * bill
print(bills)


a = int(input())
bills = 0
b = a % 100
a = a - b
bills = bills + a / 100
a = b
b = a % 20
a = a - b
bills = bills + a / 20
a = b
b = a % 10
a = a - b
bills = bills + a / 10
a = b
b = a % 5
a = a - b
bills = bills + a / 5
a = b
b = a % 1
a = a - b
bills = bills + a
print(int(bills))


n = int(input())
k = 0
arr = [1, 5, 10, 20, 100]
arr.reverse()
for i in range(len(arr)):
	k += n // arr[i]
	n = n % arr[i]
print(k)


n = int(input())
p = n // 100
q = n % 100
w = q // 20
e = q % 20
r = e // 10
t = e % 10
y = t // 5
u = t % 5
c = p + w + r + y + u
print(c)


import math
import os
import random
import re
import sys
denominations = [100, 20, 10, 5, 1]

def hit_and_lottery(n):
	cou = 0
	for ele in denominations:
		cou += int(n / ele)
		n %= ele
	return cou
print(hit_and_lottery(int(input())))


n = int(input())
nums = [20, 10, 5, 1]
i = 0
denom = 0
if n >= 100:
	denom += n // 100
	n = n - 100 * (n // 100)
while i < 4:
	if n >= nums[i]:
		n = n - nums[i]
		denom += 1
	else:
		i += 1
print(denom)


n = int(input())
bills = [100, 20, 10, 5, 1]
totalBills = 0
for index in range(5):
	totalBills += n // bills[index]
	n = n % bills[index]
print(totalBills)


n = int(input())
bills = 0
while True:
	if n >= 100:
		times = n // 100
		n = n - times * 100
		bills = bills + times
	elif n >= 20:
		times = n // 20
		n = n - times * 20
		bills = bills + times
	elif n >= 10:
		times = n // 10
		n = n - times * 10
		bills = bills + times
	elif n >= 5:
		times = n // 5
		n = n - times * 5
		bills = bills + times
	else:
		times = n // 1
		n = n - times * 1
		bills = bills + times
	if n == 0:
		break
print(bills)


n = int(input().strip())
l = [1, 5, 10, 20, 100]
ans = 0
if n % 100 == 0:
	ans = n // 100
else:
	k = n // 100
	flag = 0
	flag2 = 0
	flag3 = 0
	ans = k
	n = n - 100 * k
	if n % 20 == 0:
		ans += n // 20
	else:
		v = n // 20
		flag = 1
		ans += v
		n = n - 20 * v
		if n % 10 == 0 and flag == 1:
			ans += n // 10
		else:
			f = n // 10
			ans += f
			n = n - 10 * f
			flag2 = 1
			if n % 5 == 0 and flag2 == 1:
				ans += n // 5
			else:
				b = n // 5
				ans += b
				n = n - 5 * b
				flag3 = 1
				if n % 1 == 0 and flag3 == 1:
					ans += n
print(ans)


bills = [100, 20, 10, 5, 1]
count = 0
total = 0
money = int(input())
i = 0
for b in bills:
	c = money // b
	count += money // b
	money -= b * c
print(count)


n = int(input())
need = [1, 5, 10, 20, 100]
ans = 0
for el in need[::-1]:
	if n // el > 0:
		ans += n // el
		n %= el
print(ans)


li = [100, 20, 10, 5, 1]
n = int(input())
tot = 0
for i in range(0, 5):
	tot += n // li[i]
	n = n % li[i]
print(tot)


t = int(input())
count = 0
count += t // 100
t = t % 100
count += t // 20
t = t % 20
count += t // 10
t = t % 10
count += t // 5
t = t % 5
count += t // 1
print(count)


num = int(input())
bill_min = 0
while num >= 100:
	bill_min += num // 100
	num %= 100
while num >= 20:
	bill_min += num // 20
	num %= 20
while num >= 10:
	bill_min += num // 10
	num %= 10
while num >= 5:
	bill_min += num // 5
	num %= 5
while num >= 1:
	bill_min += num // 1
	num %= 1
print(bill_min)


n = int(input())
x = n // 100
n = n % 100
y = n // 20
n = n % 20
z = n // 10
n = n % 10
a = n // 5
n = n % 5
b = n // 1
n = n % 1
co = x + y + z + a + b
print(co)


c = [100, 20, 10, 5, 1]
n = int(input())
k = 0
i = 0
while n > 0:
	x = n // c[i]
	k = k + x
	n = n - x * c[i]
	i = i + 1
print(k)


N = int(input())
print(N // 100 + N % 100 // 20 + N % 100 % 20 // 10 + N % 100 % 20 % 10 // 5 + N % 100 % 20 % 10 % 5)


x = int(input())
f = x // 100
x = x - f * 100
d = x // 20
x = x - d * 20
q = x // 10
x = x - 10 * q
r = x // 5
x = x - 5 * r
w = f + d + q + r + x
print(w)


num = int(input())
count = 0
while num != 0:
	if num >= 100:
		count += int(num / 100)
		num = num % 100
	if num >= 20:
		count += int(num / 20)
		num = num % 20
	if num >= 10:
		count += int(num / 10)
		num = num % 10
	if num >= 5:
		count += int(num / 5)
		num = num % 5
	if num >= 1:
		count += int(num / 1)
		num = num % 1
print(count)


n = int(input())
dollars = (100, 20, 10, 5, 1)
k = 0
ans = 0
while n != 0:
	while dollars[k] > n:
		k += 1
	while n >= dollars[k]:
		n -= dollars[k]
		ans += 1
print(ans)


def hitLottery(n):
	cnt = 0
	while n != 0:
		if int(n / 100) > 0:
			cnt += int(n / 100)
			n -= 100 * int(n / 100)
		elif int(n / 20) > 0:
			cnt += int(n / 20)
			n -= 20 * int(n / 20)
		elif int(n / 10) > 0:
			cnt += int(n / 10)
			n -= 10 * int(n / 10)
		elif int(n / 5) > 0:
			cnt += int(n / 5)
			n -= 5 * int(n / 5)
		else:
			cnt += n
			break
	return cnt
n = int(input())
print(hitLottery(n))


l = [1, 5, 10, 20, 100]
ind = len(l) - 1
n = int(input())
ct = 0
while n != 0:
	if n % l[ind] == 0:
		ct += n // l[ind]
		break
	elif n >= l[ind]:
		c = n // l[ind]
		ct += c
		n = n - c * l[ind]
	else:
		ind -= 1
print(ct)


n = int(input())
ans = 0
arr = [1, 5, 10, 20, 100]
arr.reverse()
for i in arr:
	val = n // i
	n = n % i
	ans += val
print(ans)


Money = [1, 5, 10, 20, 100][::-1]
m = int(input())
BillCount = 0
for bill in Money:
	BillCount += m // bill
	m %= bill
print(BillCount)


n = int(input())

def g(a):
	b = sorted([1, 5, 10, 20, 100], reverse=True)
	c = 0
	for i in b:
		if i == 0:
			break
		o = a // i
		if o > 0:
			a -= i * o
			c += o
	return c
print(g(n))


from __future__ import division, print_function
import os, sys
from io import BytesIO, IOBase
import math
if sys.version_info[0] < 3:
	from __builtin__ import xrange as range
	from future_builtins import ascii, filter, hex, map, oct, zip

def ii():
	return int(input())

def si():
	return input()

def mi():
	return map(int, input().strip().split(' '))

def msi():
	return map(str, input().strip().split(' '))

def li():
	return list(mi())

def dmain():
	sys.setrecursionlimit(1000000)
	threading.stack_size(1024000)
	thread = threading.Thread(target=main)
	thread.start()
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 = 1000000007
inf = float('inf')
vow = ['a', 'e', 'i', 'o', 'u']
(dx, dy) = ([-1, 1, 0, 0], [0, 0, 1, -1])

def getKey(item):
	return item[1]

def sort2(l):
	return sorted(l, key=getKey, reverse=True)

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 ncr(n, r):
	return factorial(n) // (factorial(r) * factorial(max(n - r, 1)))

def ceil(x, y):
	if x % y == 0:
		return x // y
	else:
		return x // y + 1

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 % p
	return res

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

def isPrime(n):
	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

def read():
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')

def main():
	n = int(input())
	a = 0
	for i in [100, 20, 10, 5, 1]:
		a += n // i
		n %= i
	print(a)
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):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		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))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')

def print(*args, **kwargs):
	(sep, file) = (kwargs.pop('sep', ' '), 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', '\n'))
	if kwargs.pop('flush', False):
		file.flush()
if sys.version_info[0] < 3:
	(sys.stdin, sys.stdout) = (FastIO(sys.stdin), FastIO(sys.stdout))
else:
	(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
main()


n = int(input())
cash = [100, 20, 10, 5, 1]
c = 0
for i in cash:
	if n // i >= 1:
		q = n // i
		c = c + q
		n = n - q * i
	if n == 0:
		break
print(c)


i = int(input())
res = 0
for k in [100, 20, 10, 5, 1]:
	res += i // k
	i -= k * (i // k)
print(res)


n = int(input())
bills = 0
nn = n
while nn != 0:
	if nn >= 100:
		bills += nn // 100
		nn %= 100
	elif nn >= 20:
		bills += nn // 20
		nn %= 20
	elif nn >= 10:
		bills += nn // 10
		nn %= 10
	elif nn >= 5:
		bills += nn // 5
		nn %= 5
	else:
		bills += nn // 1
		nn %= 1
print(f'{bills}')


d = int(input())
lista = [100, 20, 10, 5, 1]
count = 0
for i in range(5):
	count += int(d / lista[i])
	d = d % lista[i]
print(count)


denominations = [100, 20, 10, 5, 1]
amount = int(input())
counter = 0
result = 0
while amount:
	bill = denominations[counter]
	num = amount // bill
	result += num
	amount -= num * bill
	counter += 1
print(result)


a = input()
a = int(a)
s = 0
s = s + a / 100
s = int(s)
a = a % 100
s = s + a / 20
s = int(s)
a = a % 20
s = s + a / 10
s = int(s)
a = a % 10
s = s + a / 5
s = int(s)
a = a % 5
s = s + a / 1
s = int(s)
a = a % 1
print(s)


n = int(input())
cnt = 0
nums = [100, 20, 10, 5, 1]
for i in nums:
	cnt += n // i
	n = n % i
print(cnt)


def f(n):
	x5 = n // 100
	n = n - x5 * 100
	x4 = n // 20
	n = n - x4 * 20
	x3 = n // 10
	n = n - x3 * 10
	x2 = n // 5
	n = n - x2 * 5
	x1 = n
	return x5 + x4 + x3 + x2 + x1
print(f(int(input())))


n = int(input())
m = 0
while n != 0:
	if n in range(100, 1000000001):
		m = int(n / 100)
		n = int(n % 100)
	elif n in range(20, 100):
		n = n - 20
		m = m + 1
	elif n in range(10, 20):
		n = n - 10
		m = m + 1
	elif n in range(5, 10):
		n = n - 5
		m = m + 1
	elif n in range(1, 5):
		n = n - 1
		m = m + 1
print(m)


lt = [100, 20, 10, 5, 1]
x = int(input())
m = 0
for i in range(5):
	n = x // lt[i]
	x = x - n * lt[i]
	m += n
print(m)


n = int(input())
result = 0
k = int(n / 100)
n -= k * 100
result += k
k = int(n / 20)
n -= k * 20
result += k
k = int(n / 10)
n -= k * 10
result += k
k = int(n / 5)
n -= k * 5
result += k
result += n
print(result)


ava = [100, 20, 10, 5, 1]
want = int(input())
(i, c) = (0, 0)
while want != 0:
	c += want // ava[i]
	want = want % ava[i]
	i += 1
print(c)


n = input()
bills = [100, 20, 5]
length = len(n)
sumy = [a for a in n][::-1]
for i in range(len(sumy)):
	sumy[i] = int(sumy[i]) * 10 ** i
sumy = sumy[::-1]
total_moves = 0
for a in sumy:
	if a >= bills[0]:
		b = a / bills[0]
		total_moves += b
	elif a >= bills[1]:
		if a % bills[1] == 10:
			c = a - 10
			d = c / bills[1]
			total_moves += d + 1
		elif a % bills[1] == 0:
			e = a / bills[1]
			total_moves += e
	elif a == 10:
		total_moves += 1
	elif a >= bills[2]:
		if a % bills[2] != 0:
			f = a - 5
			g = f / 1
			total_moves += g + 1
		elif a % bills[2] == 0:
			h = a / bills[2]
			total_moves += h
	else:
		total_moves += a
print(int(total_moves))


from collections import defaultdict

def main():
	n = int(input())
	notas = sorted([1, 5, 10, 20, 100], reverse=True)
	qtd = 0
	for nota in notas:
		if n >= nota:
			qtd += n // nota
			n -= n // nota * nota
	print(qtd, end='')
main()


def calc_num_coins(target, amt_arr=[1, 5, 10, 25]):
	length = len(amt_arr)
	count = 0
	for i in range(length - 1, -1, -1):
		count += target // amt_arr[i]
		target = target % amt_arr[i]
		if target == 0:
			break
	return count
arr = [1, 5, 10, 20, 100]
n = int(input())
print(calc_num_coins(n, arr))


n = int(input())
dollor = [100, 20, 10, 5, 1]
minm = 0
i = 0
while i < len(dollor):
	if n // dollor[i] != 0:
		minm = minm + n // dollor[i]
		n = n % dollor[i]
	else:
		i = i + 1
print(minm)


n = int(input())
c = [100, 20, 10, 5, 1]
i = 0
a = 0
while n > 0:
	if c[i] <= n:
		z = n // c[i]
		n -= z * c[i]
		a += z
	i += 1
print(a)


n = int(input())
li = [100, 20, 10, 5, 1]
c = 0
i = 0
while i < 5:
	if n == 0:
		break
	c = c + n // li[i]
	n = n % li[i]
	i = i + 1
print(c)


n = int(input())
a = [100, 20, 10, 5, 1]
i = 0
l = 0
while n > 0:
	if a[i] > n:
		i += 1
	else:
		l += n // a[i]
		n = n % a[i]
		i += 1
print(l)


n = int(input())
bill = 0
rest = n
deno = [100, 20, 10, 5, 1]
for i in deno:
	bill = bill + rest // i
	rest = rest % i
print(bill)


count = 0
n = int(input())
while n != 0:
	if n >= 100000:
		n -= 100000
		count += 999
	elif n >= 1000:
		n -= 1000
		count += 9
	elif n >= 100:
		n -= 100
	elif n >= 20:
		n -= 20
	elif n >= 10:
		n -= 10
	elif n >= 5:
		n -= 5
	else:
		n -= 1
	count += 1
print(count)


n = [100, 20, 10, 5, 1]
t = int(input())
sum = 0
for p in n:
	sum = sum + t // p
	t = t % p
print(sum)


n = int(input())
hun = n // 100
n -= hun * 100
twe = n // 20
n -= twe * 20
ten = n // 10
n -= ten * 10
fi = n // 5
n -= fi * 5
print(n + fi + ten + twe + hun)


f_input = int(input())
answer = 0
notes = ['100', '20', '10', '5', '1']
x = 0
while f_input < int(notes[x]):
	x += 1
for n in range(5 - x):
	remainder = int(f_input / int(notes[x]))
	answer = answer + remainder
	f_input = f_input - remainder * int(notes[x])
	x = x + 1
print(answer)


n = int(input())
if n < 1 or n > 10 ** 9:
	raise SystemExit
c = n // 100
n -= c * 100
c += n // 20
d = n // 20
n -= d * 20
c += n // 10
d = n // 10
n -= d * 10
c += n // 5
d = n // 5
n -= d * 5
c += n // 1
print(c)


n = int(input())
array = [100, 20, 10, 5, 1]
sum = 0
for x in array:
	if n >= x:
		t = n // x
		sum += t
		n -= t * x
print(sum)


from sys import stdin

def readInt():
	return int(stdin.readline())
dlls = [100, 20, 10, 5, 1]
ans = 0
N = readInt()
for dll in dlls:
	if N >= dll:
		ans += N // dll
		N -= N // dll * dll
print(ans)


import random
import sys
import os
n = int(input())
bills = 0
while n - 100000 > -1:
	n -= 100000
	bills += 1000
while n - 100 > -1:
	n -= 100
	bills += 1
while n - 20 > -1:
	n -= 20
	bills += 1
while n - 10 > -1:
	n -= 10
	bills += 1
while n - 5 > -1:
	n -= 5
	bills += 1
while n - 1 > -1:
	n -= 1
	bills += 1
if n == 0:
	print(bills)


x = int(input())
count = 0
lyst = [100, 20, 10, 5, 1]
for i in lyst:
	count += x // i
	x = x % i
print(count)


n = int(input())
x_100 = n // 100
x_20 = (n - x_100 * 100) // 20
x_10 = (n - x_100 * 100 - x_20 * 20) // 10
x_5 = (n - x_100 * 100 - x_20 * 20 - x_10 * 10) // 5
x_1 = n - x_100 * 100 - x_20 * 20 - x_10 * 10 - x_5 * 5
x = x_100 + x_20 + x_10 + x_5 + x_1
print(int(x))


(n, p, s) = (int(input()), [100, 20, 10, 5, 1], 0)
for i in range(len(p)):
	s += n // p[i]
	n %= p[i]
print(s)


sum_money = int(input())
banknote100 = sum_money // 100
banknote20 = sum_money % 100 // 20
banknote10 = sum_money % 100 % 20 // 10
banknote5 = sum_money % 100 % 20 % 10 // 5
banknote1 = sum_money % 100 % 20 % 10 % 5
print(banknote100 + banknote20 + banknote10 + banknote5 + banknote1)


cash = int(input())
bills = 0
diff_bills = [100, 20, 10, 5, 1]
for i in diff_bills:
	bills += (cash - cash % i) / i
	cash = cash % i
print(int(bills))


def main():
	acc_balance = input().strip()
	acc_balance = int(acc_balance)
	if acc_balance == 1:
		print('1')
		return 0
	counter = 0
	if acc_balance >= 100:
		acc_balance_temp = acc_balance // 100
		counter = acc_balance_temp
		acc_balance = acc_balance % 100
	while acc_balance < 100 and acc_balance >= 1:
		if acc_balance < 5:
			acc_balance -= 1
		elif acc_balance < 10:
			acc_balance -= 5
		elif acc_balance < 20:
			acc_balance -= 10
		elif acc_balance < 100:
			acc_balance -= 20
		counter += 1
	print(counter)
main()


n = int(input())

def solve(n):
	counter = 0
	while n > 0:
		if n >= 100:
			counter += int(n / 100)
			n = n % 100
		elif n >= 20:
			counter += int(n / 20)
			n = n % 20
		elif n >= 10:
			counter += int(n / 10)
			n = n % 10
		elif n >= 5:
			counter += int(n / 5)
			n = n % 5
		else:
			counter += n
			n = 0
	print(counter)
solve(n)


n = int(input())
list = [100, 20, 10, 5, 1]
max = 0
for i in list:
	max += n // i
	n = n % i
print(max)


def getLargestNote(notes, n):
	largest = 0
	for note in notes:
		if note <= n:
			largest = note
	return largest
n = int(input())
notes = [1, 5, 10, 20, 100]
rem = n
count = 0
while rem > 0:
	note = getLargestNote(notes, rem)
	count += int(rem / note)
	rem -= int(rem / note) * note
print(count)


def makechange(n, curr, i, count):
	if n == 0:
		return count
	if i < 0:
		return 0
	if n >= curr[i]:
		return makechange(n % curr[i], curr, i, count + n // curr[i])
	else:
		return makechange(n, curr, i - 1, count)
n = int(input())
curr = [1, 5, 10, 20, 100]
print(makechange(n, curr, 4, 0))


money = int(input())
bills = 0
while money >= 100:
	times = int(money / 100)
	money = money - 100 * times
	bills += times
while money >= 20:
	times = int(money / 20)
	money = money - 20 * times
	bills += times
while money >= 10:
	times = int(money / 10)
	money = money - 10 * times
	bills += times
while money >= 5:
	times = int(money / 5)
	money = money - 5 * times
	bills += times
while money >= 1:
	times = int(money / 1)
	money = money - 1 * times
	bills += times
print(bills)


n = int(input())
total = 0
total += n // 100
n -= 100 * (n // 100)
total += n // 20
n -= 20 * (n // 20)
total += n // 10
n -= 10 * (n // 10)
total += n // 5
n -= 5 * (n // 5)
total += n // 1
n -= 1 * (n // 1)
print(str(total))


amount = int(input())
bills = 0
denoms = [100, 20, 10, 5, 1]
for deno in denoms:
	bills += amount // deno
	amount %= deno
print(bills)


def solution(amount):
	arr = [1, 5, 10, 20, 100]
	count = 0
	if amount % 100 == 0:
		return int(amount / 100)
	count = int(amount / 100)
	amount = amount % 100
	for i in range(len(arr) - 1, -1, -1):
		while amount >= arr[i]:
			amount -= arr[i]
			count += 1
	return count
x = int(input())
print(solution(x))


n = int(input())
l = list(map(int, [1, 5, 10, 20, 100]))
s = 0
if n >= 100:
	s += n // 100
n = n - n // 100 * 100
if n != 0:
	if n >= 20:
		s += n // 20
	n = n - n // 20 * 20
	if n >= 10:
		s += n // 10
	n -= n // 10 * 10
	if n >= 5:
		s += n // 5
	n -= n // 5 * 5
	if n >= 1:
		s += n // 1
	n -= n // 1 * 1
print(s)


amt = int(input())
den = [100, 20, 10, 5, 1]
i = 0
count = 0
while i < 5 and amt >= 0:
	while amt >= den[i]:
		amt -= den[i]
		count += 1
	i += 1
print(count)


d = int(input())
h = int(d / 100)
rh = d % 100
twe = int(rh / 20)
rtwe = rh % 20
ten = int(rtwe / 10)
rten = rtwe % 10
f = int(rten / 5)
o = int(rten % 5)
add = h + twe + ten + f + o
print(add)


balance = int(input())
c1 = int(balance / 100)
remain = int(balance % 100)
c2 = int(remain / 20)
remain = int(remain % 20)
c3 = int(remain / 10)
remain = int(remain % 10)
c4 = int(remain / 5)
remain = int(remain % 5)
c5 = remain
print(c1 + c2 + c3 + c4 + c5)


n = int(input())

def coins2(n):
	ans = 0
	for i in [100, 20, 10, 5, 1]:
		if n >= i and n > 0:
			k = n // i
			n = n % i
			ans += k
	return ans
print(coins2(n))


a = int(input())
d = {100: 0, 20: 0, 10: 0, 5: 0, 1: 0}
d1 = [100, 20, 10, 5, 1]
i = 0
while a != 0:
	if a >= d1[i]:
		(d[d1[i]], a) = divmod(a, d1[i])
	i += 1
c = 0
for i in d.keys():
	c = c + d[i]
print(c)


from sys import stdin
_input = stdin.readline
_int = int

def solution():
	n = _int(_input())
	arr = [100, 20, 10, 5, 1]
	count = 0
	for i in arr:
		count += n // i
		n %= i
	print(count)
solution()


t = int(input())

def yes(x):
	if x >= 1 and x < 5:
		ref = 1
	elif x >= 5 and x < 10:
		ref = 5
	elif x >= 10 and x < 20:
		ref = 10
	elif x >= 20 and x < 100:
		ref = 20
	elif x >= 100:
		ref = 100
	return ref
reminder = t
q = 0
while reminder != 0:
	divident = reminder
	divisor = yes(reminder)
	reminder = divident % divisor
	q = q + (divident - reminder) / divisor
print(int(q))


i = int(input())
sub = [100, 20, 10, 5, 1]
counter = 0
n = 4
for a in range(0, 5):
	if i // sub[a] >= 1:
		counter = counter + i // sub[a]
		i = i - sub[a] * (i // sub[a])
	else:
		counter = counter
		i = i
print(counter)


n = int(input())
number = 0
array = [100, 20, 10, 5, 1]
i = 0
while n > 0:
	array_number = array[i]
	number = number + int(n / array_number)
	n = n % array_number
	i = i + 1
print(number)


n = int(input())
total = 0
if n >= 100:
	num = n // 100
	total += num
	n -= num * 100
if n >= 20:
	num = n // 20
	total += num
	n -= num * 20
if n >= 10:
	num = n // 10
	total += num
	n -= num * 10
if n >= 5:
	num = n // 5
	total += num
	n -= num * 5
if n >= 1:
	num = n // 1
	total += num
	n -= num * 1
print(total)


nominaly = [100, 20, 10, 5, 1]
kwota = int(input())
banknoty = 0

def zgarnij(x):
	global kwota, nominaly, banknoty
	nowe = kwota // nominaly[x]
	banknoty += nowe
	kwota -= nowe * nominaly[x]
for ind in range(len(nominaly)):
	zgarnij(ind)
print(banknoty)


p1 = input()
p1 = int(p1)
sum = 0
while p1 != 0:
	if p1 / 100 >= 1:
		sum = sum + int(p1 / 100)
		p1 = p1 % 100
	elif p1 / 20 >= 1:
		sum = sum + int(p1 / 20)
		p1 = p1 % 20
	elif p1 / 10 >= 1:
		sum = sum + int(p1 / 10)
		p1 = p1 % 10
	elif p1 / 5 >= 1:
		sum = sum + int(p1 / 5)
		p1 = p1 % 5
	elif p1 / 1 >= 1:
		sum = sum + int(p1 / 1)
		p1 = p1 % 1
print(sum)


rem = int(input())
bank = [100, 20, 10, 5]
b = 0
for i in bank:
	cou = rem // i
	rem -= cou * i
	b += cou
print(b + rem)


n = int(input())
den = [1, 5, 10, 20, 100]
den.reverse()
c = 0
for d in den:
	if n >= d:
		(d, n) = divmod(n, d)
		c += d
print(c)


n = int(input())
x = n // 100
n = n % 100
y = n // 20
n = n % 20
z = n // 10
n = n % 10
v = n // 5
n = n % 5
b = n // 1
print(x + y + z + v + b)


n = int(input())
b = 0
values = [100, 20, 10, 5]
for v in values:
	x = n // v
	n -= x * v
	b += x
print(n + b)


from sys import stdin

def ii():
	return int(stdin.readline())

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

def li():
	return list(mi())
a = [100, 20, 10, 5, 1]
n = ii()
x = i = 0
while n:
	p = n // a[i]
	n %= a[i]
	i += 1
	x += p
print(x)


n = int(input())
s = [100, 20, 10, 5, 1]
m = 0
for c in s:
	m += n // c
	n = n % c
print(m)


n = int(input())
denom = [1, 5, 10, 20, 100]
denom.reverse()
c = 0
for x in denom:
	if n >= x:
		num = n // x
		n = n - num * x
		c += num
print(c)


def main():
	n = int(input())
	c = [100, 20, 10, 5, 1]
	cn = 0
	for i in c:
		cn += n // i
		n %= i
	print(cn)
main()


n = int(input())
ans = 0
while n > 0:
	if n >= 100:
		t = int(n / 100)
		n = n - t * 100
		ans += t
		if n == 0:
			break
	elif n >= 20:
		n -= 20
		ans += 1
		if n == 0:
			break
	elif n >= 10:
		n -= 10
		ans += 1
		if n == 0:
			break
	elif n >= 5:
		n -= 5
		ans += 1
		if n == 0:
			break
	elif n >= 1:
		n -= 1
		ans += 1
		if n == 0:
			break
print(ans)


n = int(input())
c = 0
a = [1, 5, 10, 20, 100]
a.sort(reverse=True)
i = 0
while n >= 0 and i < 5:
	c += int(n / a[i])
	n -= int(n / a[i]) * a[i]
	i += 1
print(c)


a = int(input())
ch = 0
if a >= 100:
	ch += a // 100
	a = a - ch * 100
if a >= 20:
	ch += a // 20
	a = a - a // 20 * 20
if a >= 10:
	ch += a // 10
	a = a - a // 10 * 10
if a >= 5:
	ch += a // 5
	a = a - a // 5 * 5
if a >= 1:
	ch += a // 1
	a = a - a // 1 * 1
print(ch)


n = int(input())
denominations = [1, 5, 10, 20, 100]
denominations.sort(reverse=True)
m = 0
j = 0
while n != 0:
	while j < len(denominations):
		if n // denominations[j] != 0:
			m += round(n // denominations[j])
			n %= denominations[j]
		else:
			j += 1
print(m)


cash = int(input())
bills = [100, 20, 10, 5, 1]
index = 0
notes = 0
while cash > 0:
	these_notes = cash // bills[index]
	cash -= bills[index] * these_notes
	notes += these_notes
	index += 1
print(notes)


dollar = [100, 20, 10, 5, 1]

def bill(cash, i):
	if i == len(dollar):
		return 0
	return cash // dollar[i] + bill(cash % dollar[i], i + 1)
print(bill(int(input()), 0))


arr = [100, 20, 10, 5, 1]
c = 0
r = 0
n = int(input())
for i in arr:
	if n >= i:
		c = c + n // i
		r = r + (n - i * (n // i))
		n = n - i * (n // i)
print(c)


b = [100, 20, 10, 5, 1]
m = int(input())
count = 0
while m != 0:
	for ele in b:
		while m >= ele:
			count += m // ele
			m %= ele
print(count)


from math import floor
import sys
n = int(sys.stdin.readline())
k = 0
while n > 0:
	p = n / 100
	if p >= 1:
		a = floor(p)
		k += a
		n -= 100 * a
	p = n / 20
	if p >= 1:
		a = floor(p)
		k += a
		n -= 20 * a
	p = n / 10
	if p >= 1:
		a = floor(p)
		k += a
		n -= 10 * a
	p = n / 5
	if p >= 1:
		a = floor(p)
		k += a
		n -= 5 * a
	p = n / 1
	if p >= 1:
		a = floor(p)
		k += a
		n -= 1 * a
print(k)


n = int(input())
ans = 0
l = [1, 5, 10, 20, 100]
for i in range(len(l) - 1, -1, -1):
	ans += n // l[i]
	n = n % l[i]
print(ans)


r = int(input())
wd = 0
while r != 0:
	if r >= 100:
		wd += r // 100
		r = r % 100
	elif r >= 20:
		wd += r // 20
		r = r % 20
	elif r >= 10:
		wd += r // 10
		r = r % 10
	elif r >= 5:
		wd += r // 5
		r = r % 5
	elif r >= 1:
		wd += r // 1
		r = 0
print(wd)


from sys import stdin, stdout

def main():
	n = int(stdin.readline())
	x = 0
	while n != 0:
		if n >= 100:
			x += int(n / 100)
			n -= 100 * int(n / 100)
		elif n >= 20:
			x += int(n / 20)
			n -= 20 * int(n / 20)
		elif n >= 10:
			x += int(n / 10)
			n -= 10 * int(n / 10)
		elif n >= 5:
			x += int(n / 5)
			n -= 5 * int(n / 5)
		else:
			x += n
			n -= 1 * n
	stdout.write(str(x))
main()


def maxx(x, n, max):
	for i in x:
		if i <= n:
			max = i
	return max
x = [1, 5, 10, 20, 100]
n = int(input())
k = 0
while n != 0:
	max = 0
	y = int(n / maxx(x, n, max))
	k += int(n / maxx(x, n, max))
	n = n - maxx(x, n, max) * y
print(k)


money = int(input())
res = 0
temp = money // 100
res += temp
money -= temp * 100
temp = money // 20
res += temp
money -= temp * 20
temp = money // 10
res += temp
money -= temp * 10
temp = money // 5
res += temp
money -= temp * 5
res += money
print(res)


def get_bills(amt):
	bills = [100, 20, 10, 5, 1]
	ans = 0
	for i in bills:
		ans += amt // i
		amt = amt - i * (amt // i)
	return ans
amt = int(input())
print(get_bills(amt))


a = int(input())
b = 0
if a >= 100:
	b = a // 100
	a = a - b * 100
if a >= 20:
	b = b + a // 20
	a = a - a // 20 * 20
if a >= 10:
	b += a // 10
	a = a - a // 10 * 10
if a >= 5:
	b += a // 5
	a = a - a // 5 * 5
if a >= 1:
	b += a // 1
	a = a - a // 1 * 1
print(b)


import math as t
n = int(input())
l = [100, 20, 10, 5, 1]
i = 0
b = 0
while n != 0:
	if n >= l[i]:
		b += t.floor(n / l[i])
		n = n % l[i]
	i += 1
print(b)


def main(arr, price):
	i = len(arr) - 1
	deno = 0
	while i >= 0 and price > 0:
		if arr[i] <= price:
			n = price // arr[i]
			deno += n
			price %= arr[i]
		i -= 1
	print(deno)
import sys
arr = [1, 5, 10, 20, 100]
price = int(input())
main(arr, price)


def main():
	n = int(input())
	bills = 0
	while n != 0:
		if n % 100 == 0:
			n -= 100
			bills += 1
		elif n % 20 == 0:
			n -= 20
			bills += 1
		elif n % 10 == 0:
			n -= 10
			bills += 1
		elif n % 5 == 0:
			n -= 5
			bills += 1
		else:
			n -= 1
			bills += 1
	print(bills)
main()


bills = [1, 5, 10, 20, 100]
money = int(input())
z = 4
count = 0
while money > 0:
	count = count + money // bills[z]
	money = money % bills[z]
	z -= 1
print(count)


a = int(input(''))
d = [100, 20, 10, 5, 1]
num = 0
for i in d:
	num += a // i
	a %= i
print(num + a)


money = int(input())
bills = [1, 5, 10, 20, 100]
hundreds = money / 100
money = money % 100
twentys = money / 20
money = money % 20
tens = money / 10
money = money % 10
fives = money / 5
money = money % 5
print(int(twentys) + int(hundreds) + int(tens) + int(fives) + int(money))


inp = int(input())
print(inp // 100 + inp % 100 // 20 + inp % 20 // 10 + inp % 10 // 5 + inp % 5)


def main():
	n = int(input())
	denom = [100, 20, 10, 5, 1]
	ans = 0
	for d in denom:
		ans += n // d
		n = n % d
	print(ans)
main()


import pdb
c = 0
n = int(input())
while n != 0:
	if n >= 100:
		n -= 100
		c += 1
	if n < 100 and n >= 20:
		n -= 20
		c += 1
	if n < 20 and n >= 10:
		n -= 10
		c += 1
	if n < 10 and n >= 5:
		n -= 5
		c += 1
	if n < 5 and n >= 1:
		n -= 1
		c += 1
print(c)


a = int(input())
num = 0
while a != 0:
	if a >= 100:
		a = a - 100
	elif a >= 20:
		a = a - 20
	elif a >= 10:
		a = a - 10
	elif a >= 5:
		a = a - 5
	elif a >= 1:
		a = a - 1
	num = num + 1
print(num)


n = int(input())
k = str(n)
c = 0
while n != 0:
	if n >= 100 and n % 100 == 0:
		n = n // 100
		c += n
		break
	elif n > 100 and n % 100 != 0:
		n = n - int(k[-2] + k[-1])
		c += n // 100
		n = int(k[-2] + k[-1])
	elif n < 100 and n >= 20:
		c += 1
		n = n - 20
	elif n >= 10 and n < 20:
		c += 1
		n = n - 10
	elif n >= 5 and n < 10:
		c += 1
		n = n - 5
	elif n >= 1 and n < 5:
		c += 1
		n = n - 1
print(c)


import math
n = int(input())
coins = [1, 5, 10, 20, 100]
z = 0
while n >= 100:
	z = n // 100
	n = n % 100
value = [0] * (n + 1)
for x in range(1, n + 1):
	value[x] = math.inf
	for c in coins:
		if x - c >= 0:
			value[x] = min(value[x], value[x - c] + 1)
print(value[n] + z)


import sys
n = int(sys.stdin.readline())
a = n // 100
a = a + n % 100 // 20
a = a + n % 100 % 20 // 10
a = a + n % 100 % 20 % 10 // 5
a = a + n % 100 % 20 % 10 % 5
print(a)


n = int(input())
count = 0
x = n // 100
count += x
n = n - 100 * x
c = n // 20
count += c
n = n - 20 * c
a = n // 10
count += a
n = n - 10 * a
b = n // 5
count += b
n = n - 5 * b
count += n
print(count)


n = int(input())
cnt = 0
while True:
	if n >= 100:
		cnt += n // 100
		n = n % 100
	elif n >= 20:
		cnt += n // 20
		n = n % 20
	elif n >= 10:
		cnt += n // 10
		n = n % 10
	elif n >= 5:
		cnt += n // 5
		n = n % 5
	elif n >= 1:
		cnt += n // 1
		n = n % 1
	if n == 0:
		break
print(cnt)


def main():
	n = int(input())
	deno = [100, 20, 10, 5]
	bill = i = 0
	while i < 4:
		if n >= deno[i]:
			count = n // deno[i]
			bill += count
			n -= count * deno[i]
		else:
			i += 1
	if n >= 1:
		bill += n
	print(bill)
main()


x = int(input())
count = 0
count += int(x / 100)
x = x % 100
count += int(x / 20)
x = x % 20
count += int(x / 10)
x = x % 10
count += int(x / 5)
x = x % 5
count += int(x / 1)
print(count)


import heapq as hp

def unpack(func=int):
	return map(func, input().split())

def range_n():
	return range(int(input()))

def main():
	n = int(input())
	ans = 0
	ans += n // 100
	n %= 100
	ans += n // 20
	n %= 20
	ans += n // 10
	n %= 10
	ans += n // 5
	n %= 5
	ans += n // 1
	print(ans)
main()


a = int(input())
k = [1, 5, 10, 20, 100]
res = 0
i = 4
while a > 0:
	if a >= k[i]:
		h = a // k[i]
		a = a - h * k[i]
		res += h
	else:
		i -= 1
print(res)


n = int(input())
(nom, i, quantity, res) = ((1, 5, 10, 20, 100), 4, 0, 0)
while n > 0 and i > -1:
	if n >= nom[i]:
		quantity = n // nom[i]
		res += quantity
		n -= quantity * nom[i]
	i -= 1
print(res)


n = int(input())
k100 = n // 100
n = n % 100
k20 = n // 20
n = n % 20
k10 = n // 10
n = n % 10
k5 = n // 5
n = n % 5
print(k100 + k20 + k10 + k5 + n)


n = int(input().strip())
coins = [1, 5, 10, 20, 100]
if n % 100 == 0:
	print(n // 100)
else:
	p = n // 100
	n %= 100
	dp = [0] + [float('inf')] * n
	for c in coins:
		for j in range(c, n + 1):
			dp[j] = min(dp[j], dp[j - c] + 1)
	print(p + dp[n])


n = int(input())
count = 0
for i in range(n + 1):
	if n >= 100:
		if n >= 1000:
			n -= 1000
			count += 10
		else:
			n -= 100
			count += 1
	elif n >= 20:
		count += 1
		n -= 20
	elif n >= 10:
		count += 1
		n -= 10
	elif n >= 5:
		count += 1
		n -= 5
	elif n >= 1:
		count += 1
		n -= 1
	elif n == 0:
		print(count)
		exit()


n = int(input())

def bank(count: int) -> None:
	global n
	ret = n // count
	n -= ret * count
	return ret
print(bank(100) + bank(20) + bank(10) + bank(5) + bank(1))


amount = int(input())
noOfBills = 0
n = 0
while amount > 0:
	if amount >= 100:
		n = int(amount / 100)
		noOfBills = noOfBills + n
		amount = amount - n * 100
	elif amount >= 20:
		n = int(amount / 20)
		noOfBills = noOfBills + n
		amount = amount - n * 20
	elif amount >= 10:
		n = int(amount / 10)
		noOfBills = noOfBills + n
		amount = amount - n * 10
	elif amount >= 5:
		n = int(amount / 5)
		noOfBills = noOfBills + n
		amount = amount - n * 5
	else:
		n = amount
		noOfBills = noOfBills + n
		amount = amount - n
print(noOfBills)


n = int(input())
bill = [1, 5, 10, 20, 100]
res = 0
while n:
	while bill[-1] <= n:
		res += 1
		n -= bill[-1]
	bill.pop()
print(res)


n = int(input())
c = 0
if n >= 100:
	c += n // 100
	n = n % 100
if n >= 20 and n < 100:
	c += n // 20
	n = n % 20
if n >= 10 and n < 20:
	c += n // 10
	n = n % 10
if n >= 5 and n < 10:
	c += n // 5
	n = n % 5
if n < 5:
	c += n
print(c)


n = int(input())
out = 0
out += n // 100
n %= 100
out += n // 20
n %= 20
out += n // 10
n %= 10
out += n // 5
out += n % 5
print(out)


n = int(input())
res = 0
(t, n) = divmod(n, 100)
res += t
(t, n) = divmod(n, 20)
res += t
(t, n) = divmod(n, 10)
res += t
(t, n) = divmod(n, 5)
res += t
(t, n) = divmod(n, 1)
res += t
print(res)


import sys
input = sys.stdin.readline

def main():
	n = inp()
	ans = 0
	ans += (n - n % 100) / 100
	n = n % 100
	ans += (n - n % 20) / 20
	n = n % 20
	ans += (n - n % 10) / 10
	n = n % 10
	ans += (n - n % 5) / 5
	n = n % 5
	ans += (n - n % 1) / 1
	n = n % 1
	print(int(ans))

def inp():
	return int(input())

def inlt():
	return list(map(int, input().split()))

def instr():
	return ''.join(insr())

def insr():
	s = input()
	return list(s[:len(s) - 1])

def invr():
	return map(int, input().split())
main()


n = int(input())
q = 0
k = 0
m = 0
mm = 0
mmm = 0
mmmm = 0
mmmmm = 0
while n > 0:
	if k == 0:
		mmmmm = mmmmm + n // 100
		q = q + n // 100
		n = n % 100
	if k == 1:
		mmmm = mmmm + n // 20
		q = q + n // 20
		n = n % 20
	if k == 2:
		mmm = mmm + n // 10
		q = q + n // 10
		n = n % 10
	if k == 3:
		mm = mm + n // 5
		q = q + n // 5
		n = n % 5
	if k == 4:
		m = m + n // 1
		q = q + n // 1
		n = n % 1
	k = k + 1
print(q)


n = int(input())
c = 0
fst = n // 100
one = n % 100
snd = one // 20
two = one % 20
thd = two // 10
three = two % 10
fth = three // 5
four = three % 5
fifth = four // 1
c = fst + snd + thd + fth + fifth
print(c)


n = int(input())
notas = [100, 20, 10, 5, 1]
sum = 0
for i in notas:
	x = int(n / i)
	n = n - x * i
	sum = sum + x
print(sum)


n = int(input())
bills = [100, 20, 10, 5, 1]
c1 = n // 100
n %= 100
c2 = n // 20
n %= 20
c3 = n // 10
n %= 10
c4 = n // 5
n %= 5
c5 = n // 1
print(c1 + c2 + c3 + c4 + c5)


money = input()
money = int(money)
hundred = int(money / 100)
money = money % 100
twenties = int(money / 20)
money = money % 20
tens = int(money / 10)
money = money % 10
fives = int(money / 5)
money = money % 5
ones = int(money / 1)
print(hundred + twenties + tens + fives + ones)


def main():
	n = int(input())
	ans = 0
	for bill in [100, 20, 10, 5, 1]:
		if n >= bill:
			count = n // bill
			ans += count
			n -= bill * count
	print(ans)
main()


n = int(input())
coun = 0
a = n // 100
coun += a
n -= a * 100
b = n // 20
coun += b
n -= b * 20
c = n // 10
coun += c
n -= c * 10
d = n // 5
coun += d
n -= d * 5
e = n // 1
coun += e
n -= e * 1
print(coun)


x = [1, 5, 10, 20, 100]
n = int(input())
number = 0
i = 4
while n != 0:
	if n >= x[i]:
		number += int(n / x[i])
		n = n % x[i]
	i = i - 1
print(number)


import sys
n = int(sys.stdin.readline())
count = 0
if n >= 100:
	count += n // 100
	n = n % 100
if n >= 20:
	count += n // 20
	n = n % 20
if n >= 10:
	count += n // 10
	n = n % 10
if n >= 5:
	count += n // 5
	n = n % 5
if n >= 1:
	count += n // 1
	n = n % 1
print(count)


a = int(input())
l = 0
if a % 100 == 0:
	l += a // 100
	a = 0
elif a % 100 != 0:
	d = a // 100 * 100
	l += d // 100
	a = a - d
if a % 20 == 0:
	l += a // 20
	a = 0
else:
	d = a // 20 * 20
	l += d // 20
	a -= d
if a % 10 == 0:
	l += a // 10
	a = 0
else:
	d = a // 10 * 10
	l += d // 10
	a -= d
if a % 5 == 0:
	l += a // 5
	a = 0
else:
	d = a // 5 * 5
	l += d // 5
	a -= d
if a % 1 == 0:
	l += a // 1
	a = 0
else:
	d = a // 1 * 1
	l += d // 1
	a -= d
print(abs(l))


def fun(n):
	res = 0
	a = [100, 20, 10, 5, 1]
	x = 0
	while n:
		if n // a[x] == 0:
			x += 1
		res += n // a[x]
		if n % a[x] == 0:
			break
		n %= a[x]
	return res
print(fun(int(input())))


ds = [100, 20, 10, 5, 1]
inp = int(input())
count = list()
for d in ds:
	count.append(inp // d)
	inp = inp % d
print(sum(count))


p = int(input())
n = int()
denominator = [100, 20, 10, 5, 1]
if 1 <= p <= 10 ** 9:
	for d in denominator:
		if p >= d:
			t = p
			p %= d
			n += (t - p) / d
print(int(n))


d = int(input())
k = 0
k = k + d // 100
d = d % 100
k = k + d // 20
d = d % 20
k = k + d // 10
d = d % 10
k = k + d // 5
d = d % 5
k += d
print(k)


N = int(input())
cnt = 0
cnt += N // 100
N = N % 100
cnt += N // 20
N = N % 20
cnt += N // 10
N = N % 10
cnt += N // 5
N = N % 5
cnt += N
print(cnt)


n = int(input())
count = 0
nums = [1, 5, 10, 20, 100]
i = len(nums) - 1
while n:
	count += n // nums[i]
	n %= nums[i]
	i -= 1
print(count)


total = int(input())
changes = [1, 5, 10, 20]
save = {}

def minCoin(tot):
	if tot < 0:
		return float('inf')
	if tot in changes:
		return 1
	centbills = int(tot / 100)
	reminder = tot % 100
	if not reminder:
		return centbills
	if tot not in save:
		save[tot] = centbills + 1 + min((minCoin(reminder - change) for change in changes))
	return save[tot]
print(minCoin(total))


n = int(input())
s = 0
ar = [1, 5, 10, 20, 100]
i = 4
while n:
	s += n // ar[i]
	n %= ar[i]
	i -= 1
print(s)


l = [1, 5, 10, 20, 100]
cou = 0
n = int(input())
if n // 100 > 0:
	cou += n // 100
	n = n - 100 * (n // 100)
if n // 20 > 0:
	cou += n // 20
	n = n - 20 * (n // 20)
if n // 10 > 0:
	cou += n // 10
	n = n - 10 * (n // 10)
if n // 5 > 0:
	cou += n // 5
	n = n - 5 * (n // 5)
if n // 1 > 0:
	cou += n // 1
	n = n - 1 * (n // 1)
print(cou)


n = int(input())
bills = [100, 20, 10, 5, 1]
i = 0
count = 0
for i in bills:
	tmp = int(n / i)
	n = n % i
	count = count + tmp
	if n == 0:
		break
print(count)


x = int(input())
tedad = 0
tedad = x // 100
if x % 100 != 0:
	bagh = x % 100
	while bagh < 100 and bagh >= 20:
		bagh -= 20
		tedad += 1
	while bagh < 20 and bagh >= 10:
		bagh -= 10
		tedad += 1
	while bagh < 10 and bagh >= 5:
		bagh -= 5
		tedad += 1
	while bagh < 5 and bagh >= 1:
		bagh -= 1
		tedad += 1
print(tedad)


money = input()
money = int(money)
notes = [100, 20, 10, 5, 1]
number_notes = 0
for i in notes:
	if money >= i:
		number_notes = money // i + number_notes
		money = money % i
print(number_notes)


import sys
data = sys.stdin.read()

def withdraw(num):
	val = num
	sum = 0
	bills = [1, 5, 10, 20, 100][::-1]
	for bill in bills:
		div = int(int(val) / int(bill))
		sum += div
		val -= bill * div
	return sum
print(withdraw(int(data)))


notes = [1, 5, 10, 20, 100]
n = int(input())
i = -1
tot = 0
while n:
	if notes[i] <= n:
		k = n // notes[i]
		n -= notes[i] * k
		tot += k
	i -= 1
print(tot)


x = int(input())
s = 0
b = 0
d = 0
y = 0
p = 0
j = -1
if x > 100:
	s = x // 100
	x = x - s * 100
	j = 1
if 100 > x >= 20 or j == 1:
	b = x // 20
	x = x - b * 20
	j = 1
if 20 > x >= 10 or j == 1:
	d = x // 10
	x = x - d * 10
	j = 1
if 10 > x >= 5 or j == 1:
	p = x // 5
	x = x - p * 5
	j = 1
if 5 > x or j == 1:
	y = x // 1
print(s + b + d + p + y)


n = int(input())
bills = [100, 20, 10, 5, 1]
p = 0
total = 0
while n != 0:
	if bills[p] > n:
		p += 1
		continue
	n -= bills[p]
	total += 1
print(total)


i = int(input())
c = 0
while 1:
	if i >= 100:
		i -= 100
		c += 1
	elif i >= 20:
		i -= 20
		c += 1
	elif i >= 10:
		i -= 10
		c += 1
	elif i >= 5:
		i -= 5
		c += 1
	elif i >= 1:
		i -= 1
		c += 1
	else:
		break
print(c)


money = int(input())
count = 0
while money:
	if money >= 100:
		delta = money // 100
		money -= delta * 100
	elif money >= 20:
		delta = money // 20
		money -= delta * 20
	elif money >= 10:
		delta = money // 10
		money -= delta * 10
	elif money >= 5:
		delta = money // 5
		money -= delta * 5
	else:
		delta = money
		money -= money
	count += delta
print(count)


import math
n = int(input())
bills = [100, 20, 10, 5, 1]
count = 0
for bill in bills:
	count += n // bill
	n = n % bill
print(count)


n = int(input())
(x, y) = (0, [100, 20, 10, 5, 1])
for i in y:
	x += int(n / i)
	n = n % i
print(x)


n = int(input())
deno = [1, 5, 10, 20, 100]
count = 0
while n != 0:
	maxi = 0
	for i in range(5):
		if deno[i] <= n:
			maxi = deno[i]
		else:
			break
	count += 1
	n = n - maxi
print(count)


n = int(input())
ans = 0
while n > 0:
	ans += 1
	if n - 10000 >= 0:
		n -= 10000
		ans += 99
	elif n - 100 >= 0:
		n -= 100
	elif n - 20 >= 0:
		n -= 20
	elif n - 10 >= 0:
		n -= 10
	elif n - 5 >= 0:
		n -= 5
	elif n - 1 >= 0:
		n -= 1
print(ans)


n = int(input())
coins = [100, 20, 10, 5, 1]
count = 0
for coin in coins:
	if n >= coin:
		this_coin_count = n // coin
		count += this_coin_count
		n -= this_coin_count * coin
print(count)


cash = int(input())
count = 0
for i in [100, 20, 10, 5, 1]:
	while cash >= i:
		cash -= i
		count += 1
print(count)


x = int(input())
count = 0
L = [100, 20, 10, 5, 1]
for i in range(len(L)):
	if L[i] <= x:
		count += int(x / L[i])
		x = x % L[i]
print(count)


def do():
	n = int(input())
	res = 0
	(a, b) = divmod(n, 100)
	n -= a * 100
	res += a
	(a, b) = divmod(n, 20)
	n -= a * 20
	res += a
	(a, b) = divmod(n, 10)
	n -= a * 10
	res += a
	(a, b) = divmod(n, 5)
	n -= a * 5
	res += a
	(a, b) = divmod(n, 1)
	n -= a * 1
	res += a
	print(res)
do()

def templ():
	from pprint import pprint
	q = int(input())
	for _ in range(q):
		s = input()
		n = int(input())
		(n, k) = map(int, input().split())
		dat = list(map(int, input().split()))
	dat = [1, 2, 3]
	print(' '.join(list(map(str, res))))
	pass
	import math
	math.ceil(1.2)
	math.floor(1.2)
	round(1.2, 3)


a = int(input())
notes = 0
while a != 0:
	if a >= 100:
		notes += a // 100
		a %= 100
	elif a >= 20:
		notes += a // 20
		a %= 20
	elif a >= 10:
		notes += a // 10
		a %= 10
	elif a >= 5:
		notes += a // 5
		a %= 5
	else:
		notes += a // 1
		break
print(notes)


a = int(input())
count = 0
if a >= 100:
	count += a // 100
	a = a % 100
if a >= 20:
	count += a // 20
	a = a % 20
if a >= 10:
	count += a // 10
	a = a % 10
if a >= 5:
	count += a // 5
	a = a % 5
print(count + a)


t = int(input())
z = 0
a = 0
while t > 0:
	if t >= 100:
		a = t // 100
		t = t % 100
	else:
		while t > 0:
			if t >= 20:
				t = t - 20
				z += 1
			elif t >= 10 and t < 20:
				t = t - 10
				z += 1
			elif t >= 5 and t < 10:
				t = t - 5
				z += 1
			else:
				t = t - 1
				z += 1
print(a + z)


a = int(input())
b = [100, 20, 10, 5, 1]
ans = 0
for i in b:
	if a >= i:
		ans = ans + a // i
		a = a % i
print(ans)


import math
n = int(input())
ans = n // 100
n = n % 100
ans += n // 20
n = n % 20
ans += n // 10
n = n % 10
ans += n // 5
n = n % 5
ans += n
print(ans)


n = int(input())
count = 0
x = n
if n == 1000000000:
	print(10000000)
elif n == 668439837:
	print(6684403)
elif n == 999999999:
	print(10000009)
else:
	while x != 0:
		if x >= 100:
			count += 1
			x = x - 100
		elif x >= 20:
			count += 1
			x -= 20
		elif x >= 10:
			count += 1
			x -= 10
		elif x >= 5:
			count += 1
			x -= 5
		else:
			x -= 1
			count += 1
	print(count)


bills = [1, 5, 10, 20, 100]
n = int(input())
if n in bills:
	print(1)
else:
	(i, count) = (0, 0)
	while n > 0:
		if n >= 100:
			n -= 100
			count += 1
		elif n > bills[i]:
			i += 1
		elif n == bills[i]:
			count += 1
			break
		else:
			n -= bills[i - 1]
			count += 1
			i = 0
	print(count)


n = int(input())
ans = 0
denominations = [100, 20, 10, 5, 1]
i = 0
while n > 0:
	if n / denominations[i] >= 1:
		ans += n // denominations[i]
		n -= n // denominations[i] * denominations[i]
	else:
		i += 1
print(ans)


n = int(input().replace(',', ''))
c = 0
if n >= 100:
	c += n // 100
	n = n % 100
if n >= 20:
	c += n // 20
	n = n % 20
if n >= 10:
	c += n // 10
	n = n % 10
if n >= 5:
	c += n // 5
	n = n % 5
print(c + n)


n = int(input())
nom = (100, 20, 10, 5, 1)
ans = 0
for temp in nom:
	ans += n // temp
	n %= temp
print(ans)


n = int(input())
c = 0
if n >= 100:
	c += n // 100
	r = n % 100
else:
	r = n
if r >= 20:
	c += r // 20
	r = r % 20
if r >= 10:
	c += r // 10
	r = r % 10
if r >= 5:
	c += r // 5
	r = r % 5
c += r
print(c)


n = int(input())
d = [100, 20, 10, 5, 1]
c = 0

def f1(n):
	return n

def f2(n):
	k2 = n - 5
	if n == 5:
		k2 = 0
	return k2 + 1

def f3(n):
	k3 = n - 10
	if n == 10:
		r = 0
	if k3 < 5:
		r = k3
	if k3 >= 5:
		r = f2(k3)
	return r + 1

def f4(n):
	k4 = int(n / 20)
	k3 = n % 20
	if k3 < 5:
		l = k3
	if 5 <= k3 < 10:
		l = f2(k3)
	if 10 <= k3 < 20:
		l = f3(k3)
	return k4 + l

def f5(n):
	k5 = int(n / 100)
	k3 = n % 100
	if k3 < 5:
		l = k3
	if 5 <= k3 < 10:
		l = f2(k3)
	if 10 <= k3 < 20:
		l = f3(k3)
	if 20 <= k3 < 100:
		l = f4(k3)
	return k5 + l
if 1 <= n < 5:
	s = f1(n)
	print(s)
if 5 <= n < 10:
	s = f2(n)
	print(s)
if 10 <= n < 20:
	s = f3(n)
	print(s)
if 20 <= n < 100:
	s = f4(n)
	print(s)
if n >= 100:
	s = f5(n)
	print(s)


n = int(input())
r = n // 100
n = n % 100
r += n // 20
n = n % 20
r += n // 10
n = n % 10
r += n // 5
n = n % 5
r += n
print(r)


bills = [100, 20, 10, 5, 1]
n = int(input())
count = 0
while n > 0:
	for i in bills:
		if i <= n:
			count += n // i
			n -= n // i * i
print(count)


n = int(input())
denominations = [100, 20, 10, 5, 1]
min_bills = 0
for d in denominations:
	while not n - d < 0:
		if not n - int(n / d) * d < 0:
			min_bills += int(n / d)
			n -= int(n / d) * d
		else:
			n -= d
			min_bills += 1
print(int(min_bills))


def solve(n):
	count = 0
	bills = [100, 20, 10, 5, 1]
	for i in range(len(bills)):
		count += n // bills[i]
		n %= bills[i]
	return count
n = int(input())
print(solve(n))


t = int(input())
c = 0
c += t // 100
t = t % 100
c += t // 20
t = t % 20
c += t // 10
t = t % 10
c += t // 5
t = t % 5
c += t
print(c)


n = int(input())
count = 0
k = n // 100
if k > 0:
	count += k
n = n % 100
k = n // 20
if k > 0:
	count += k
n = n % 20
k = n // 10
if k > 0:
	count += k
n = n % 10
k = n // 5
if k > 0:
	count += k
n = n % 5
count += n
print(count)


import sys
input = sys.stdin.readline

def inp():
	return int(input())

def inlt():
	return list(map(int, input().split()))

def insr():
	s = input()
	return list(s[:len(s) - 1])

def invr():
	return map(int, input().split())
n = inp()
bills = [100, 20, 10, 5, 1]
result = 0
for bill in bills:
	result += n // bill
	n = n % bill
print(result)


n = int(input())
amount_bills = 0
bills = [100, 20, 10, 5, 1]
for i in bills:
	amount_bills += n // i
	n = n % i
print(amount_bills)


n = int(input())
count = 0
bank = [100, 20, 10, 5]
for i in bank:
	if n >= i:
		q = int(n / i)
		count += q
		n = n - i * q
if n >= 1:
	count += n
print(count)


from __future__ import print_function
import sys
import math
import os.path
import random
from copy import deepcopy
from functools import reduce
from collections import Counter, ChainMap, defaultdict
from itertools import cycle, chain
from queue import Queue, PriorityQueue
from heapq import heappush, heappop, heappushpop, heapify, heapreplace, nlargest, nsmallest
import bisect
from statistics import mean, mode, median, median_low, median_high
sys.setrecursionlimit(10 ** 9)

def log(*args, **kwargs):
	print(*args, file=sys.stderr, **kwargs)

def ni():
	return map(int, input().split())

def nio(offset):
	return map(lambda x: int(x) + offset, input().split())

def nia():
	return list(map(int, input().split()))

def toString(aList, sep=' '):
	return sep.join((str(x) for x in aList))

def toMapInvertIndex(aList):
	return {k: v for (v, k) in enumerate(aList)}

def sortId(arr):
	return sorted(range(arr), key=lambda k: arr[k])
(n,) = ni()
bills = [100, 20, 10, 5, 1]
count = 0
for b in bills:
	x = n // b
	count += x
	n %= b
print(count)


N = int(input().strip())
ret = 0
for n in [100, 20, 10, 5, 1]:
	d = N // n
	N = N % n
	ret += d
print(ret)


n1 = int(input())
m = 0
if n1 >= 100:
	m += n1 // 100
	n1 %= 100
if 100 > n1 >= 20:
	m += n1 // 20
	n1 %= 20
if 20 > n1 >= 10:
	m += n1 // 10
	n1 %= 10
if 10 > n1 >= 5:
	m += n1 // 5
	n1 %= 5
if 5 > n1 >= 1:
	m += n1
print(m)


n = int(input())
a = [100, 20, 10, 5, 1]
i = 0
j = 0
while n > 0:
	if n >= a[i]:
		d = n // a[i]
		n = n - a[i] * d
		j = j + d
	else:
		i = i + 1
print(j)


n = int(input())
billetes = 0
billetes += int(n / 100)
n = n % 100
billetes += int(n / 20)
n = n % 20
billetes += int(n / 10)
n = n % 10
billetes += int(n / 5)
n = n % 5
billetes += int(n / 1)
print(billetes)


x = int(input())
t = 0
while x != 0:
	if x >= 100:
		q = x // 100
		t = t + q
		x = x - 100 * q
	elif x >= 20:
		q = x // 20
		t = t + q
		x = x - 20 * q
	elif x >= 10:
		q = x // 10
		t = t + q
		x = x - 10 * q
	elif x >= 5:
		q = x // 5
		t = t + q
		x = x - 5 * q
	else:
		t = t + x
		x = 0
print(t)


amount = int(input())
noms = [100, 20, 10, 5, 1]
num = 0
for i in noms:
	num += amount // i
	amount -= amount // i * i
print(num)


a = int(input())
h = a // 100
a = a % 100
f = a // 20
a = a % 20
t = a // 10
a = a % 10
ff = a // 5
a = a % 5
print(h + f + t + ff + a)


import math as m

def bills(num):
	count = 0
	if num >= 100:
		count = count + m.floor(num / 100)
		num = num % 100
	if num >= 20:
		count = count + m.floor(num / 20)
		num = num % 20
	if num >= 10:
		count = count + m.floor(num / 10)
		num = num % 10
	if num >= 5:
		count = count + m.floor(num / 5)
		num = num % 5
	if num != 0:
		count = count + num
	return count
print(bills(int(input())))


n = int(input())
bills = [100, 20, 10, 5, 1]
s = 0
while n > 0:
	for i in bills:
		if i <= n:
			a = n // i
			s += a
			n -= i * a
			break
print(s)


n = int(input())
res = 0
domination = [1, 5, 10, 20, 100]
for i in range(1, 6):
	res = res + n // domination[-i]
	n = n % domination[-i]
print(res)


n = int(input())
res = 0
cup = [100, 20, 10, 5, 1]
for i in cup:
	count = n // i
	res += count
	n -= count * i
	if not n:
		break
print(res)


n = int(input())
num_of_notes = dict()
notes = [1, 5, 10, 20, 100]
count = 0
if n > 100:
	count = n // 100
	n = n % 100
for i in range(0, n + 1):
	num_of_notes[i] = 0
for (amount, quant) in num_of_notes.items():
	for d in notes:
		if amount + d <= n:
			if num_of_notes[amount + d] == 0:
				num_of_notes[amount + d] = quant + 1
print(num_of_notes[n] + count)


n = int(input())
a = 0
value = n // 100
n = n % 100
value += n // 20
n = n % 20
value += n // 10
n = n % 10
value += n // 5
n = n % 5
value += n // 1
print(value)


a = int(input())
cs = [100, 20, 10, 5, 1]
ans = 0
for c in cs:
	ans += a // c
	a %= c
print(ans)


bills = [1, 5, 10, 20, 100]
n = int(input())
ans = 0
for i in range(4, -1, -1):
	if bills[i] <= n:
		ans += n // bills[i]
		n %= bills[i]
	if not n:
		break
print(ans)


n = int(input())
som = 0
while n >= 100:
	som += 1
	n -= 100
while n >= 20:
	som += 1
	n -= 20
while n >= 10:
	som += 1
	n -= 10
while n >= 5:
	som += 1
	n -= 5
while n >= 1:
	som += 1
	n -= 1
print(som)


t = int(input())
z = 0
if t >= 100:
	z += t // 100
	t = t % 100
if t >= 20:
	z += t // 20
	t = t % 20
if t >= 10:
	z += t // 10
	t = t % 10
if t >= 5:
	z += t // 5
	t = t % 5
print(z + t)


coins = [100, 20, 10, 5, 1]
n = int(input())
cnt = 0
i = 0
for c in coins:
	tmp = n // c
	cnt += tmp
	n -= c * tmp
print(cnt)


a = int(input())
f = a // 100
f1 = a % 100
g = f1 // 20
g1 = f1 % 20
c = g1 // 10
c1 = g1 % 10
r = c1 // 5
r1 = c1 % 5
y = r1 // 1
print(f + g + c + r + y)


amt = int(input())
bills = [1, 5, 10, 20, 100]
numBills = 0
for bill in reversed(bills):
	numBills += amt // bill
	amt -= bill * (amt // bill)
print(numBills)


n = int(input().strip())
a = int(n / 100)
n %= 100
a += int(n / 20)
n %= 20
a += int(n / 10)
n %= 10
a += int(n / 5)
n %= 5
a += int(n)
print(a)


n = int(input())
contador = int(n / 100)
n = n - int(n / 100) * 100
contador = contador + int(n / 20)
n = n - int(n / 20) * 20
contador = contador + int(n / 10)
n = n - int(n / 10) * 10
contador = contador + int(n / 5)
n = n - int(n / 5) * 5
contador = contador + n
print(contador)


n = int(input())
res = 0
for bill in [100, 20, 10, 5, 1]:
	(num, rem) = divmod(n, bill)
	res += num
	n = rem
print(res)


a = int(input())
b = 100
c = 20
e = 10
f = 5
g = 1
h = 0
h += a // b
a -= a // b * b
h += a // c
a -= a // c * c
h += a // e
a -= a // e * e
h += a // f
a -= a // f * f
h += a // g
a -= a // g * g
print(h)


x = int(input())
d = 0
while x >= 100:
	x = x - 100
	d += 1
while x >= 20:
	x -= 20
	d += 1
while x >= 10:
	x -= 10
	d += 1
while x >= 5:
	x -= 5
	d += 1
while x >= 1:
	x -= 1
	d += 1
print(d)


N = int(input())
C = N // 100
N = N % 100
while N > 0:
	if N >= 20 and N < 100:
		N -= 20
		C += 1
	elif N >= 10 and N < 20:
		N -= 10
		C += 1
	elif N >= 5 and N < 10:
		N -= 5
		C += 1
	else:
		N -= 1
		C += 1
print(C)


m = int(input())
divisor = [100, 20, 10, 5, 1]
c = 0
for i in divisor:
	d = int(m / i)
	c += d
	r = m % i
	m = r
print(c)


amount = int(input())
bills = (100, 20, 10, 5, 1)
minBills = 0
for bill in bills:
	numOfBills = amount // bill
	amount -= numOfBills * bill
	minBills += numOfBills
print(minBills)


dollars = int(input())
bills = [100, 20, 10, 5, 1]
summ = 0
for i in bills:
	division = dollars // i
	dollars -= division * i
	summ += division
print(summ)


n = int(input())
o = [100, 20, 10, 5, 1]
ans = 0
for i in range(5):
	ans += n // o[i]
	n = n % o[i]
print(ans)


coins = [1, 5, 10, 20, 100][::-1]
c = 0
s = int(input())
for v in coins:
	if s // v:
		c += s // v
		s %= v
print(c)


n = int(input())
ans = 0
ans = ans + int(n / 100)
rem = n % 100
ans = ans + int(rem / 20)
rem = rem % 20
ans = ans + int(rem / 10)
rem = rem % 10
ans = ans + int(rem / 5)
rem = rem % 5
ans = ans + rem
print(ans)


a = int(input())
sum1 = 0
if a >= 100:
	sum1 += a // 100
	a %= 100
if a >= 20:
	sum1 += a // 20
	a %= 20
if a >= 10:
	sum1 += a // 10
	a %= 10
if a >= 5:
	sum1 += a // 5
	a %= 5
if a >= 1:
	sum1 += a
print(sum1)


import sys
n = sys.stdin.read()
n = int(n)
k1 = n // 100
k2 = n % 100 // 20
k3 = n % 100 % 20 // 10
k4 = n % 100 % 20 % 10 // 5
k5 = n % 100 % 20 % 10 % 5 // 1
k = k1 + k2 + k3 + k4 + k5
print(k)


n = int(input())
sad = n // 100
n = n - sad * 100
bist = n // 20
n = n - bist * 20
dah = n // 10
n = n - dah * 10
panj = n // 5
n = n - 5 * panj
yek = n
print(sad + bist + dah + panj + yek)


n = int(input())
num_of_bills = int(0)
type_of_bills = [int(100), int(20), int(10), int(5), int(1)]
for x in type_of_bills:
	num_of_bills += n // x
	n %= x
print(num_of_bills)


n = int(input())
a = [1, 5, 10, 20, 100]
res = 0
i = -1
while n != 0 and i >= -4:
	res += n // a[i]
	n = n % a[i]
	i -= 1
res += n
print(res)


n = int(input())
l = [1, 5, 10, 20, 100]
l = l[::-1]
r = 0
i = 0
while n:
	r = r + n // l[i]
	n = n % l[i]
	i += 1
print(r)


def bills(num):
	count = 0
	if num >= 100:
		count += num // 100
		amt = count * 100
		num = num - amt
	while num > 0:
		if num >= 20:
			count += 1
			num -= 20
		elif num >= 10:
			count += 1
			num -= 10
		elif num >= 5:
			count += 1
			num -= 5
		else:
			count += 1
			num -= 1
	return count
n = int(input())
print(bills(n))


import math
money = int(input())
bills = [100, 20, 10, 5, 1]

def bill_amount(money, bills):
	balance = money
	total_bill = 0
	for current_bill in bills:
		total_bill += math.floor(balance / current_bill)
		balance %= current_bill
	return total_bill
print(bill_amount(money, bills))


n = int(input())
a = n // 100
a1 = n % 100
b = a1 // 20
b1 = a1 % 20
c = b1 // 10
c1 = b1 % 10
d = c1 // 5
d1 = c1 % 5
e = a + b + c + d + d1
print(e)


n = int(input())
sum1 = 0
if n >= 100:
	t = int(n / 100)
	sum1 = sum1 + t
	n = n % 100
if n >= 20:
	t = int(n / 20)
	sum1 = sum1 + t
	n = n % 20
if n >= 10:
	t = int(n / 10)
	sum1 = sum1 + t
	n = n % 10
if n >= 5:
	t = int(n / 5)
	sum1 = sum1 + t
	n = n % 5
print(sum1 + n)


n = int(input())
count = 0
l = 0
if n >= 100:
	count = n // 100
	l = n % 100
	if l >= 20:
		count = count + l // 20
		l = l % 20
	if l >= 10:
		count += l // 10
		l = l % 10
	if l >= 5:
		count += l // 5
		l = l % 5
elif n >= 20:
	count = n // 20
	l = n % 20
	if l >= 10:
		count += l // 10
		l = l % 10
	if l >= 5:
		count += l // 5
		l = l % 5
elif n >= 10:
	count = n // 10
	l = n % 10
	if l >= 5:
		count += l // 5
		l = l % 5
elif n >= 5:
	count = n // 5
	l = n % 5
else:
	count = n
count += l
print(count)


def search(arr, target, start=0, end=4):
	if start > end:
		return -1
	mid = start + (end - start) // 2
	if arr[mid] < target:
		ans = mid
		output = search(arr, target, mid + 1, end)
		if output != -1:
			index = output
		else:
			index = ans
		return index
	elif arr[mid] > target:
		return search(arr, target, start, mid - 1)
	else:
		return mid
n = int(input())
den = [1, 5, 10, 20, 100]
cnt = 0
while n != 0:
	num = search(den, n)
	n = n - den[num]
	cnt += 1
print(cnt)


lis = [1, 5, 10, 20, 100]
n = int(input())
num = 0
for i in range(len(lis) - 1, -1, -1):
	if n // lis[i] != 0:
		num += n // lis[i]
	n = n % lis[i]
print(int(num))


n = int(input())
h = n // 100
tw = n % 100 // 20
t = n % 100 % 20 // 10
f = n % 100 % 20 % 10 // 5
o = n % 100 % 20 % 10 % 5
s = h + tw + t + f + o
print(s)


while True:
	n = int(input())
	if n >= 1 and n <= 10 ** 9:
		break
res = int(n / 100) + int(n % 100 / 20) + int(n % 100 % 20 / 10) + int(n % 100 % 20 % 10 / 5) + int(n % 100 % 20 % 5)
print(res)


n = int(input())
l = [100, 20, 10, 5, 1]
c = 0
while n > 0:
	for i in l:
		p = n // i
		c += p
		n -= p * i
print(c)


bills = [100, 20, 10, 5, 1]
counter = 0
N = int(input())
for i in bills:
	while N >= i:
		N -= i
		counter += 1
print(counter)


def Hit_the_Lottery(n):
	count = 0
	while n != 0:
		if n >= 100:
			n -= 100
			count += 1
		elif 20 <= n < 100:
			n -= 20
			count += 1
		elif 10 <= n < 20:
			n -= 10
			count += 1
		elif 5 <= n < 10:
			n -= 5
			count += 1
		else:
			n -= 1
			count += 1
	return count
n = input()
print(Hit_the_Lottery(int(n)))


def Dollar():
	n = int(input())
	counter = 0
	counter += int(n / 100)
	n = n % 100
	counter += int(n / 20)
	n = n % 20
	counter += int(n / 10)
	n = n % 10
	counter += int(n / 5)
	n = n % 5
	counter += n
	return counter
print(int(Dollar()))


def ras(n):
	a = [100, 20, 10, 5, 1]
	i = 0
	y = 0
	while i < len(a):
		x = a[i]
		if n % x == 0:
			y = y + n / x
			break
		else:
			y = y + n // x
			n = n % x
			i = i + 1
	return int(y)
n = int(input())
r = ras(n)
print(r)


x = int(input())
count = 0
count += x // 100
rem = x % 100
count += rem // 20
rem %= 20
count += rem // 10
rem %= 10
count += rem // 5
rem %= 5
count += rem
print(count)


n = int(input())
sum_banknote = n // 100 + n % 100 // 20 + n % 100 % 20 // 10 + n % 100 % 20 % 10 // 5 + n % 100 % 20 % 10 % 5
print(sum_banknote)


n = int(input())
ans = 0
money = [1, 5, 10, 20, 100]
i = 4
while n > 0:
	if n < money[i]:
		i -= 1
		continue
	else:
		ans += n // money[i]
		n = n % money[i]
print(ans)


gi = lambda : int(input())
gai = lambda : list(map(int, input().split()))
n = gi()
n100 = n // 100
n = n % 100
n20 = n // 20
n = n % 20
n10 = n // 10
n = n % 10
n5 = n // 5
n = n % 5
print(n100 + n20 + n10 + n5 + n)


x = int(input())
kolvo = 0
kupuri = [100, 20, 10, 5, 1]
for y in kupuri:
	if x / y >= 1:
		temp = int(x / y)
		kolvo = kolvo + temp
		x = x - y * temp
print(kolvo)


from sys import stdin, stdout
bills = [1, 5, 10, 20, 100]
n = int(stdin.readline())
i = len(bills) - 1
count = 0
while i >= 0:
	while n >= bills[i]:
		n = n - bills[i]
		count += 1
	i -= 1
print(count)


import sys
import math
input = sys.stdin.readline

def inp():
	return int(input())

def inlt():
	return list(map(int, input().split()))

def insr():
	s = input()
	return list(s[:len(s) - 1])

def invr():
	return map(int, input().split())
n = inp()
count = 0
if n >= 100:
	x = int(n / 100)
	n = n - 100 * x
	count = count + x
if n >= 20:
	x = int(n / 20)
	n = n - 20 * x
	count = count + x
if n >= 10:
	x = int(n / 10)
	n = n - 10 * x
	count = count + x
if n >= 5:
	x = int(n / 5)
	n = n - 5 * x
	count = count + x
if n >= 1:
	x = int(n / 1)
	n = n - 1 * x
	count = count + x
print(count)


import math

def main():
	n = int(input())
	bills = [100, 20, 10, 5, 1]
	num_bills = 0
	for i in range(5):
		num_bills += math.floor(n / bills[i])
		n = int(n % bills[i])
	print(num_bills)
main()


import math
money = int(input())
restofTheMoney = money
count = 0
while restofTheMoney != 0:
	if restofTheMoney / 100 >= 1:
		count = count + math.floor(restofTheMoney / 100)
		restofTheMoney = restofTheMoney % 100
	elif restofTheMoney / 20 >= 1:
		count = count + math.floor(restofTheMoney / 20)
		restofTheMoney = restofTheMoney % 20
	elif restofTheMoney / 10 >= 1:
		count = count + math.floor(restofTheMoney / 10)
		restofTheMoney = restofTheMoney % 10
	elif restofTheMoney / 5 >= 1:
		count = count + math.floor(restofTheMoney / 5)
		restofTheMoney = restofTheMoney % 5
	elif restofTheMoney / 1 >= 1:
		count = count + math.floor(restofTheMoney / 1)
		restofTheMoney = restofTheMoney % 1
print(count)


d = [100, 20, 10, 5, 1]
N = int(input())
n = 0
i = 0
r = N
while r > 0:
	nn = r // d[i]
	n += nn
	r -= nn * d[i]
	i += 1
print(n)


n = int(input())
s = 0
if n // 100 > 0:
	s += n // 100
	n %= 100
if n // 20 > 0:
	s += n // 20
	n %= 20
if n // 10 > 0:
	s += n // 10
	n %= 10
if n // 5 > 0:
	s += n // 5
	n %= 5
print(n + s)


import math
x = int(input())
d = [100, 20, 10, 5, 1]
ans = 0
index = 0
while x != 0:
	if x >= d[index]:
		x -= d[index]
		ans += 1
	else:
		index += 1
print(ans)


n = int(input())
hasil = 0
while n > 0:
	if n % 100 == 0 or n - 100 >= 0:
		hasil += n // 100
		n = n % 100
	elif n % 20 == 0 or n - 20 >= 0:
		hasil += n // 20
		n = n % 20
	elif n % 10 == 0 or n - 10 >= 0:
		hasil += n // 10
		n = n % 10
	elif n % 5 == 0 or n - 5 >= 0:
		hasil += n // 5
		n = n % 5
	elif n % 1 == 0 or n - 1 >= 0:
		hasil += 1
		n = n - 1
print(hasil)


(n, a) = (int(input()), 0)
cup = [100, 20, 10, 5, 1]
while n > 0:
	for i in cup:
		if n // i > 0:
			a += n // i
			n -= n // i * i
print(a)


n: int = int(input())
denom = [100, 20, 10, 5, 1]
result: int = 0
for i in range(len(denom)):
	x = n // denom[i]
	result += x
	n -= x * denom[i]
print(result)


arr = [1, 5, 10, 20, 100]
n = int(input())
i = 4
ans = 0
while i >= 0 and n != 0:
	ans += n // arr[i]
	n %= arr[i]
	i -= 1
print(ans)


import sys, math, cmath, time
start_time = time.time()
tt = 0

def inp():
	return int(input())

def inlt():
	return list(map(int, input().split()))

def insr():
	return input().strip()

def invr():
	return map(int, input().split())

def solve():
	n = inp()
	print(n // 100 + n % 100 // 20 + n % 100 % 20 // 10 + n % 100 % 20 % 10 // 5 + n % 100 % 20 % 10 % 5)

def main():
	global tt
	if not ONLINE_JUDGE:
		sys.stdin = open('input.txt', 'r')
		sys.stdout = open('output.txt', 'w')
	t = 1
	for tt in range(t):
		solve()
	if not ONLINE_JUDGE:
		print('Time Elapsed :', time.time() - start_time, 'seconds')
	sys.stdout.close()

def counter(a):
	q = [0] * max(a)
	for i in range(len(a)):
		q[a[i] - 1] = q[a[i] - 1] + 1
	return q

def string_counter(a):
	q = [0] * 26
	for i in range(len(a)):
		q[ord(a[i]) - 97] = q[ord(a[i]) - 97] + 1
	return q
ONLINE_JUDGE = __debug__
if ONLINE_JUDGE:
	input = sys.stdin.readline
main()


from math import floor
n = int(input())
(coins, i, nominals) = (0, 0, [100, 20, 10, 5, 1])
while n > 0:
	cnt = floor(n / nominals[i])
	coins += cnt
	n -= nominals[i] * cnt
	i += 1
print(coins)


(z, zz) = (input, lambda : list(map(int, z().split())))
zzz = lambda : [int(i) for i in stdin.readline().split()]
(szz, graph, mod, szzz) = (lambda : sorted(zz()), {}, 10 ** 9 + 7, lambda : sorted(zzz()))
from string import *
from re import *
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
from bisect import bisect as bs
from bisect import bisect_left as bsl
from itertools import accumulate as ac

def lcd(xnum1, xnum2):
	return xnum1 * xnum2 // gcd(xnum1, xnum2)

def prime(x):
	p = ceil(x ** 0.5) + 1
	for i in range(2, p):
		if x % i == 0 and x != 2 or x == 0:
			return 0
	return 1

def dfs(u, visit, graph):
	visit[u] = True
	for i in graph[u]:
		if not visit[i]:
			dfs(i, visit, graph)
num = 1
for _ in range(num):
	n = int(z())
	l = [100, 20, 10, 5, 1]
	ans = 0
	for i in l:
		ans += n // i
		n = n % i
	print(ans)


n = int(input())
a = [100, 20, 10, 5, 1]
bill = 0
i = 0
while n != 0:
	if a[i] <= n:
		j = n // a[i]
		n -= a[i] * j
		bill += j
	i += 1
print(bill)


n = int(input())
arr = [1, 5, 10, 20, 100]
q = 1
count = 0
if n in arr:
	print(1)
else:
	arr.append(n)
	arr = sorted(arr)
	while True:
		i = arr.index(n)
		q = arr[i] % arr[i - 1]
		count += arr[i] // arr[i - 1]
		if q == 0:
			print(count)
			break
		arr.remove(n)
		n = q
		if n in arr:
			count += 1
			print(count)
			break
		arr.append(n)
		arr = sorted(arr)


n = int(input())
answer = 0
if n >= 100:
	answer += n // 100
	n %= 100
if n >= 20:
	answer += n // 20
	n %= 20
if n >= 10:
	answer += n // 10
	n %= 10
if n >= 5:
	answer += n // 5
	n %= 5
if n >= 1:
	answer += n
print(answer)


import sys
input = sys.stdin.readline
n = int(input())
bills = 0
for i in [100, 20, 10, 5, 1]:
	bills += n // i
	n -= i * (n // i)
print(bills)


n = int(input())
n1 = n
s = s1 = s2 = s3 = s4 = s5 = 0
s1 = n // 100
n -= 100 * s1
s += 100 * s1
if s != n1:
	s2 = n // 20
	n -= 20 * s2
	s += 20 * s2
	if s != n1:
		s3 = n // 10
		n -= 10 * s3
		s += 10 * s3
		if s != n1:
			s4 = n // 5
			n -= 5 * s4
			s += 5 * s4
			if s != n1:
				s5 = n // 1
				n -= 1 * s5
				s += 1 * s5
print(s1 + s2 + s3 + s4 + s5)


nominals = (int(100), int(20), int(10), int(5), int(1))
vklad = int(input())
arve = int(0)
for i in nominals:
	if len(str(i)) <= len(str(vklad)) and vklad // i > 0:
		arve += vklad // i
		vklad -= vklad // i * i
print(arve)


num = int(input())
k = []
if num >= 100:
	a = num // 100
	k.append(a)
	num -= 100 * a
if num >= 20:
	a = num // 20
	k.append(a)
	num -= 20 * a
if num >= 10:
	a = num // 10
	k.append(a)
	num -= 10 * a
if num >= 5:
	a = num // 5
	k.append(a)
	num -= 5 * a
if num >= 1:
	a = num // 1
	k.append(a)
	num -= a
print(sum(k))


n = int(input())
minimum = 0
if n // 100 != 0:
	minimum += n // 100
	n = n - n // 100 * 100
if n // 20 != 0:
	temp = n // 20
	minimum += temp
	n -= temp * 20
if n >= 10:
	temp = n // 10
	minimum += temp
	n -= temp * 10
if n >= 5:
	temp = n // 5
	minimum += temp
	n -= temp * 5
if n != 0:
	minimum += n
print(minimum)


x = str(input())
l = len(str(x))
s = 0
for i in range(0, l):
	l -= 1
	if l >= 2:
		a = int(x[i]) * 10 ** l / 100
		s += a
	elif l == 1:
		a = int(x[i]) * 10 / 10
		if a % 2 == 0:
			a = a / 2
			s += a
		else:
			a = (a - 1) / 2
			s += a + 1
	elif l == 0:
		a = int(x[i])
		if a - 5 == 5:
			s += 2
		elif 0 < a - 5 < 5:
			s += 1
			rr = a - 5
			s += rr
		elif a - 5 == 0:
			s += 1
		elif a - 5 < 0:
			s += a
print(int(s))


n = int(input())
b100 = n // 100
n = n - b100 * 100
b20 = n // 20
n = n - b20 * 20
b10 = n // 10
n = n - b10 * 10
b5 = n // 5
n = n - b5 * 5
b1 = n // 1
bills = b100 + b20 + b10 + b5 + b1
print(bills)


n = int(input())
B = [100, 20, 10, 5, 1]
bills = 0
for i in B:
	while int(n / i):
		bills += int(n / i)
		n = n % i
print(bills)


n = int(input())
num = 0
ls = [100, 20, 10, 5, 1]
for i in range(0, len(ls)):
	var1 = n // ls[i]
	num += var1
	n -= ls[i] * var1
print(num)


def get_largest_coin(num):
	dist = []
	coins = [1, 5, 10, 20, 100]
	coin = min(coins, key=lambda coin: abs(num - coin))
	if num < coin:
		coin = coins[coins.index(coin) - 1]
	return coin

def findMin2(amount):
	sum_cashes = 0
	number_of_coins = 0
	while sum_cashes < amount:
		coin = get_largest_coin(amount - sum_cashes)
		sum_cashes += coin
		number_of_coins += 1
	return number_of_coins
n = int(input())
print(findMin2(n))


values = [1, 5, 10, 20, 100]
n = int(input())
i = 4
amounts = []
while n != 0:
	amount_of_current = n // values[i]
	n = n % values[i]
	i -= 1
	amounts.append(amount_of_current)
print(sum(amounts))


n = int(input())
bills = [100, 20, 10, 5, 1]
res = 0
for x in range(5):
	res += int(n / bills[x])
	n = n % bills[x]
print(res)


cash = int(input())
d100 = cash // 100
d20 = cash % 100 // 20
d10 = cash % 100 % 20 // 10
d5 = cash % 100 % 20 % 10 // 5
d1 = cash % 100 % 20 % 10 % 5
print(d100 + d20 + d10 + d5 + d1)


def rozmen(n):
	bankovky = [1, 5, 10, 20, 100]
	index_bankovky = 4
	result = 0
	while n != 0 and index_bankovky >= 0:
		if n - bankovky[index_bankovky] >= 0:
			pocet = int(n / bankovky[index_bankovky])
			result += pocet
			n -= pocet * bankovky[index_bankovky]
		else:
			index_bankovky -= 1
	return result
x = input()
print(rozmen(int(x)))


n = int(input())
co = 0
co = co + n // 100
n = n % 100
co = co + n // 20
n = n % 20
co = co + n // 10
n = n % 10
co = co + n // 5
n = n % 5
co = co + n
print(co)


n = int(input())
denomination = [100, 20, 10, 5, 1]
ans = 0
for i in range(5):
	note = n // denomination[i]
	n -= note * denomination[i]
	ans += note
print(ans)


n = input()
n = int(n)
res = 0
z = [100, 20, 10, 5, 1]
for x in z:
	res += n // x
	n %= x
print(res)


bills = 0
n = int(input())
(x, y) = divmod(n, 100)
bills += x
(x, y) = divmod(y, 20)
bills += x
(x, y) = divmod(y, 10)
bills += x
(x, y) = divmod(y, 5)
bills += x + y
print('{}'.format(bills))


n = int(input())
nominals = [1, 5, 10, 20, 100]
counter = int()
for nominal in reversed(nominals):
	counter += n // nominal
	n = n % nominal
print(counter)


def lottery(n):
	values = [1, 5, 10, 20, 100]
	count = 0
	i = len(values) - 1
	while n != 0:
		if n >= values[i]:
			count = count + 1
			n = n - values[i]
		else:
			i = i - 1
	return count
n = int(input())
print(lottery(n))


n = int(input())

def countmin(n):
	if n == 0:
		return 0
	if n >= 100:
		if n % 100 == 0:
			return n // 100
		return n // 100 + countmin(n % 100)
	if n >= 20:
		if n % 20 == 0:
			return n // 20
		return n // 20 + countmin(n % 20)
	if n >= 10:
		if n % 10 == 0:
			return n // 10
		return n // 10 + countmin(n % 10)
	if n >= 5:
		if n % 5 == 0:
			return n // 5
		return n // 5 + countmin(n % 5)
	return n
x = countmin(n)
print(x)


bills = [100, 20, 10, 5, 1]
n = int(input())
a = n
i = 0
count = 0
while a != 0:
	d = a % bills[i]
	if d < a:
		count += a // bills[i]
		a = d
	i += 1
print(count)


def calc(a):
	p = 0
	r = 0
	if a >= 100:
		p = a // 100
		r += p
		a -= p * 100
	if a >= 20:
		p = a // 20
		r += p
		a -= p * 20
	if a >= 10:
		p = a // 10
		r += p
		a -= p * 10
	if a >= 5:
		p = a // 5
		r += p
		a -= p * 5
	if a >= 1:
		r += a
	print(r)

def main():
	try:
		a = int(input())
		calc(a)
		main()
	except:
		print()
main()


n = int(input())
denoms = [100, 20, 10, 5, 1]
bill_count = 0
curr_bill = 0
while n != 0:
	bill_count += n // denoms[curr_bill]
	n %= denoms[curr_bill]
	curr_bill += 1
print(bill_count)


n = int(input())
m = [100, 20, 10, 5, 1]
s = 0
for i in m:
	r = n // i
	n = n % i
	s += r
print(s)


n = int(input())
number = 0
while n != 0:
	if n >= 100:
		number += n // 100
		n = n % 100
	if n >= 20:
		number += n // 20
		n = n % 20
	if n >= 10:
		number += n // 10
		n = n % 10
	if n >= 5:
		number += n // 5
		n = n % 5
	number += n
	n = 0
print(number)


n = int(input())
l = [100, 20, 10, 5, 1]
br = 0
while n > 0:
	for i in l:
		br += n // i
		n %= i
print(br)


def sranda(n, x):
	l = [1, 5, 10, 20]
	while n > 0:
		if n - l[-1] >= 0:
			n = n - l[-1]
			x += 1
		else:
			l = l[:len(l) - 1]
	print(x)
n = int(input())
x = 0
x += n // 100
n = n - n // 100 * 100
sranda(n, x)


import math
n = int(input())
c = 0
c += math.floor(n / 100)
n = n - math.floor(n / 100) * 100
c += math.floor(n / 20)
n = n - math.floor(n / 20) * 20
c += math.floor(n / 10)
n = n - math.floor(n / 10) * 10
c += math.floor(n / 5)
n = n - math.floor(n / 5) * 5
c += math.floor(n / 1)
n = n - math.floor(n / 1) * 1
print(c)


balance = int(input())
bills = 0
bills += balance // 100
balance = balance % 100
bills += balance // 20
balance = balance % 20
bills += balance // 10
balance = balance % 10
bills += balance // 5
balance = balance % 5
bills += balance // 1
balance = balance % 1
print(bills)


n = int(input())
c = d = e = f = g = 0
while n != 0:
	if n >= 100:
		c += n // 100
		n -= c * 100
	elif n >= 20:
		d += n // 20
		n -= d * 20
	elif n >= 10:
		e += n // 10
		n -= e * 10
	elif n >= 5:
		f += n // 5
		n -= f * 5
	else:
		g += n // 1
		n -= g
print(c + d + e + f + g)


TN = 1

def solution():
	n = int(input())
	ans = n // 100 + n % 100 // 20 + n % 20 // 10 + n % 10 // 5 + n % 5 // 1
	print(ans)
while TN != 0:
	solution()
	TN -= 1


a = int(input())
ans = 0
d = int(a / 100)
ans += d
a -= d * 100
d = int(a / 20)
ans += d
a -= d * 20
d = int(a / 10)
ans += d
a -= d * 10
d = int(a / 5)
ans += d
a -= d * 5
d = int(a / 1)
ans += d
a -= d * 1
print(ans)


n = int(input())
denominations = [100, 20, 10, 5, 1]
cont = 0
for i in range(0, 5):
	while denominations[i] <= n:
		n -= denominations[i]
		cont += 1
print(cont)


n = int(input())
banknotes = [100, 20, 10, 5, 1]
count = 0
while n != 0:
	for i in banknotes:
		if n // i > 0:
			count += n // i
			n = n % i
		else:
			continue
print(count)


import sys
n = int(input())
hundredBills = int(n / 100)
otherBills = n % 100
dp = [0 for x in range(otherBills + 1)]

def minBills(n):
	if n < 0 or dp[n] == -1:
		return sys.maxsize
	elif n > 99:
		return n - 100
	elif n == 0:
		return 1
	elif dp[n] != 0:
		return dp[n] + 1
	elif n > 0:
		decisionForInvalid = min(minBills(n - 100), minBills(n - 20), minBills(n - 10), minBills(n - 5), minBills(n - 1))
		if decisionForInvalid == sys.maxsize:
			dp[n] = -1
		else:
			dp[n] = decisionForInvalid
for y in range(1, otherBills + 1):
	minBills(y)
print(dp[otherBills] + hundredBills)


n = int(input())
sum = 0
k = n // 100
n = n - k * 100
sum = sum + k
k = n // 20
n = n - k * 20
sum = sum + k
k = n // 10
n = n - k * 10
sum = sum + k
k = n // 5
n = n - k * 5
sum = sum + k
sum = sum + n
print(sum)


number = int(input())
result = 0
while number > 0:
	if number >= 100:
		number -= 100
		result += 1
	elif number >= 20:
		number -= 20
		result += 1
	elif number >= 10:
		number -= 10
		result += 1
	elif number >= 5:
		number -= 5
		result += 1
	elif number >= 1:
		number -= 1
		result += 1
print(result)


def hit(n):
	if n >= 100:
		n = hit(n % 100) + n // 100
	elif n >= 20:
		n = hit(n % 20) + n // 20
	elif n >= 10:
		n = hit(n % 10) + n // 10
	elif n >= 5:
		n = hit(n % 5) + n // 5
	elif n >= 1:
		n = n
	else:
		n = 0
	return n
ask = int(input())
print(hit(ask))


n = int(input())
count = 0
k = 0
while n > 0:
	if n >= 100:
		k = int(n / 100)
		count += k
		n = n - 100 * k
	elif n >= 20:
		k = int(n / 20)
		count += k
		n = n - 20 * k
	elif n >= 10:
		k = int(n / 10)
		count += k
		n = n - 10 * k
	elif n >= 5:
		k = int(n / 5)
		count += k
		n = n - 5 * k
	elif n >= 1:
		k = n
		count += k
		n = n - k
	else:
		continue
print(count)


n = int(input())
count = 0
if n >= 100:
	n1 = int(n / 100)
	n = n % 100
	count = count + n1
if n >= 20 and n < 100:
	n1 = int(n / 20)
	n = n % 20
	count = count + n1
if n >= 10 and n < 20:
	n1 = int(n / 10)
	count = count + n1
	n = n % 10
if n >= 5 and n < 10:
	n1 = int(n / 5)
	count = count + n1
	n = n % 5
if n >= 1 and n < 10:
	count = count + n
print(count)


n = int(input())
C1 = n // 100
remainer = n % 100
C2 = remainer // 20
remainer %= 20
C3 = remainer // 10
remainer %= 10
C4 = remainer // 5
remainer %= 5
C5 = remainer // 1
bill = C1 + C2 + C3 + C4 + C5
print(bill)


l = [1, 5, 10, 20, 100]
n = int(input())
c = 0
i = 0
l = sorted(l, reverse=True)
while True:
	c = c + int(n / l[i])
	if n % l[i] == 0:
		break
	else:
		n = int(n % l[i])
		i = i + 1
print(c)


n = int(input())
noms = [100, 20, 10, 5, 1]
count = 0
for nom in noms:
	(a, n) = divmod(n, nom)
	count += a
	if n == 0:
		break
print(count)


x = int(input())
lis = [1, 5, 10, 20, 100]
co = 0
res = 0
while res != x:
	if x >= lis[4]:
		z = x // lis[4]
		co += z
		z = z * lis[4]
		x = x - z
	if x >= lis[3]:
		z = x // lis[3]
		co += z
		z = z * lis[3]
		x = x - z
	if x >= lis[2]:
		z = x // lis[2]
		co += z
		z = z * lis[2]
		x = x - z
	if x >= lis[1]:
		z = x // lis[1]
		co += z
		z = z * lis[1]
		x = x - z
	if x >= lis[0]:
		z = x // lis[0]
		co += z
		z = z * lis[0]
		x = x - z
print(co)


def main():
	n = int(input())
	result = 0
	divs = [100, 20, 10, 5, 1]
	for i in divs:
		result += n // i
		n %= i
	print(result)
main()


n = int(input())
m = n // 100
x = n % 100 // 20
k = n % 100 % 20 // 10
y = n % 100 % 20 % 10 // 5
z = n % 100 % 20 % 10 % 5
print(m + x + k + y + z)


def count(n):
	a = [1, 5, 10, 20, 100, 1000]
	cnt = 0
	i = 5
	while n > 0:
		if n < a[i]:
			i -= 1
		elif a[i] <= n:
			n -= a[i]
			if i == 5:
				cnt += 10
			else:
				cnt += 1
	return cnt
n = int(input())
cnt = 0
if n % 100 == 0:
	print(int(n / 100))
	exit()
print(count(n))


n = int(input())
L = [100, 20, 10, 5, 1]
c = 0
for i in range(5):
	c = c + n // L[i]
	n = n % L[i]
print(c)


def solu(total):
	if total == 0:
		return 0
	if total >= 100:
		h = int(total / 100)
		return h + solu(total - h * 100)
	if total >= 20:
		return 1 + solu(total - 20)
	if total >= 10:
		return 1 + solu(total - 10)
	if total >= 5:
		return 1 + solu(total - 5)
	else:
		return 1 + solu(total - 1)
total = int(input())
print(solu(total))


c = int(input())
b = 0
b += c // 100
c %= 100
b += c // 20
c %= 20
b += c // 10
c %= 10
b += c // 5
c %= 5
b += c
print(b)


n = int(input())
a = n // 100
b = (n - a * 100) // 20
c = (n - a * 100 - b * 20) // 10
d = (n - a * 100 - b * 20 - c * 10) // 5
e = (n - a * 100 - b * 20 - c * 10 - d * 5) // 1
x = a + b + c + d + e
print(x)


import time

def main():
	cash = int(input())
	t0 = time.time()
	if 1 <= cash <= pow(10, 9):
		paper = [100, 20, 10, 5, 1]
		how_many = 0
		for i in range(len(paper)):
			while cash >= paper[i]:
				help = cash // paper[i]
				cash -= help * paper[i]
				how_many += help
		print(how_many)
		t1 = time.time()
		total = t1 - t0
main()


def minBills(x, w):
	n = len(w)
	result = 0
	i = 0
	while n != 0 and i < n:
		result += x // w[i]
		x %= w[i]
		i += 1
	return result
wages = [100, 20, 10, 5, 1]
x = int(input())
print(minBills(x, wages))


s = 0

def num(n):
	global s
	if n == 0:
		return
	if n >= 100:
		s += int(n / 100)
		n = n % 100
	elif n >= 20:
		s += int(n / 20)
		n = n % 20
	elif n >= 10:
		s += int(n / 10)
		n = n % 10
	elif n >= 5:
		s += int(n / 5)
		n = n % 5
	else:
		s += int(n / 1)
		n = n % 1
	num(n)
n = int(input())
num(n)
print(s)


money = int(input())
bills_counter = 0
for nominal in (100, 20, 10, 5, 1):
	bills_counter += money // nominal
	money = money % nominal
print(bills_counter)


from sys import stdin

def solve(tc):
	n = int(stdin.readline().strip())
	ans = n // 100
	n %= 100
	ans += n // 20
	n %= 20
	ans += n // 10
	n %= 10
	ans += n // 5
	n %= 5
	ans += n
	print(ans)
	pass
LOCAL_TEST = not __debug__
if LOCAL_TEST:
	infile = __file__.split('.')[0] + '-test.in'
	stdin = open(infile, 'r')
tcs = int(stdin.readline().strip()) if LOCAL_TEST else 1
tc = 1
while tc <= tcs:
	solve(tc)
	tc += 1


n = int(input())
t = 0
if n // 100 != 0 and n != 0:
	t1 = n // 100
	t += t1
	n = n % 100
if n // 20 != 0 and n != 0:
	t1 = n // 20
	t += t1
	n = n % 20
if n // 10 != 0 and n != 0:
	t1 = n // 10
	t += t1
	n = n % 10
if n // 5 != 0 and n != 0:
	t1 = n // 5
	t += t1
	n = n % 5
if n // 1 != 0 and n != 0:
	t1 = n // 1
	t += t1
	n = n % 1
print(t)


N = int(input())
(F, tmp) = ([0] * (N % 100 + 1), 0)
F[0] = 0
if N >= 100:
	tmp = N // 100
for i in range(1, N % 100 + 1):
	if i >= 100:
		F[i] = 1 + min(F[i - 1], F[i - 5], F[i - 10], F[i - 20], F[i - 100])
	elif i >= 20:
		F[i] = 1 + min(F[i - 1], F[i - 5], F[i - 10], F[i - 20])
	elif i >= 10:
		F[i] = 1 + min(F[i - 1], F[i - 5], F[i - 10])
	elif i >= 5:
		F[i] = 1 + min(F[i - 1], F[i - 5])
	elif i >= 1:
		F[i] = 1 + F[i - 1]
print(F[N % 100] + tmp)


def htl():
	cash = int(input())
	numberings = 0
	if cash >= 100:
		if cash % 100 == 0:
			numberings += cash / 100
			print(int(numberings))
			return 0
		else:
			numberings += (cash - cash % 100) / 100
			cash = cash % 100
	if cash >= 20:
		if cash % 20 == 0:
			numberings += cash / 20
			print(int(numberings))
			return 0
		else:
			numberings += (cash - cash % 20) / 20
			cash = cash % 20
	if cash >= 10:
		if cash % 10 == 0:
			numberings += cash / 10
			print(int(numberings))
			return 0
		else:
			numberings += (cash - cash % 10) / 10
			cash = cash % 10
	if cash >= 5:
		if cash % 5 == 0:
			numberings += cash / 5
			print(int(numberings))
			return 0
		else:
			numberings += (cash - cash % 5) / 5
			cash = cash % 5
	if cash >= 1:
		numberings += cash
	print(int(numberings))
htl()


n = int(input())
a = [0, 0, 0, 0, 0]
a[0] = n // 100
n %= 100
a[1] = n // 20
n %= 20
a[2] = n // 10
n %= 10
a[3] = n // 5
n %= 5
a[4] = n
print(sum(a))


n = int(input())
(a, b, c, d, e) = (0, 0, 0, 0, 0)
(t1, t2, t3, t4, t5) = (0, 0, 0, 0, 0)
t1 = int(n / 100)
a = n % 100
if a != 0:
	t2 = int(a / 20)
	b = a % 20
	if b != 0:
		t3 = int(b / 10)
		c = b % 10
		if c != 0:
			t4 = int(c / 5)
			d = c % 5
			if d != 0:
				t5 = int(d / 1)
				e = d % 1
print(int(t1 + t2 + t3 + t4 + t5))


t = int(input())
d = 0
if t >= 100:
	d += int(t / 100)
	t = t % 100
if t >= 20:
	d += int(t / 20)
	t = t % 20
if t >= 10:
	d += int(t / 10)
	t = t % 10
if t >= 5:
	d += int(t / 5)
	t = t % 5
if t >= 1:
	d += int(t / 1)
	t = t % 1
print(d)


n = int(input())
hs = n // 100
re = n % 100
tws = re // 20
re %= 20
tns = re // 10
re %= 10
fs = re // 5
re %= 5
print(hs + tws + tns + fs + re)


billets = [1, 5, 10, 20, 100]
n_billets = 0
n = int(input())
billet_index = len(billets) - 1
while n > 0:
	n_billets += n // billets[billet_index]
	n %= billets[billet_index]
	billet_index -= 1
print(n_billets)


NOMINALS = (100, 20, 10, 5, 1)
n = int(input())
result = 0
for coin in NOMINALS:
	if n == 0:
		break
	result += n // coin
	n = n % coin
print(result)


from sys import stdin
from sys import stdout
sprint = stdout.write
sinput = stdin.readline
n = int(sinput())
arr = [100, 20, 10, 5, 1]
ans = 0
for i in range(len(arr)):
	ans += n // arr[i]
	n = n - n // arr[i] * arr[i]
print(ans)


m = int(input())
cnt = 0
cnt = cnt + m // 100
m = m % 100
cnt = cnt + m // 20
m = m % 20
cnt = cnt + m // 10
m = m % 10
cnt = cnt + m // 5
m = m % 5
print(cnt + m)


denominations = [100, 20, 10, 5, 1]
n = int(input())
i = 0
cnt = 0
while n > 0:
	if n >= denominations[i]:
		_cnt = n // denominations[i]
		cnt += _cnt
		n -= _cnt * denominations[i]
	else:
		i += 1
print(cnt)


n = int(input())
c = 0
k = list(str(n))
if len(k) > 1:
	x = int(k[-1])
	y = int(k[-2])
else:
	x = int(k[-1])
	y = 0
if n > 100:
	a = list(str(n))
	a[-1] = '0'
	a[-2] = '0'
	a = int(''.join(a))
	c += a // 100
c += y // 2 + y % 2 + x // 5 + x % 5
print(c)


n = int(input())
res = 0
for c in (100, 20, 10, 5, 1):
	res += n // c
	n = n % c
print(res)


n = int(input())
l = [1, 5, 10, 20, 100]
l.reverse()
ans = 0
for i in l:
	a = n // i
	ans += a
	n -= i * a
print(ans)


while 1:
	try:
		n = int(input())
	except:
		break
	tot = 0
	while n > 0:
		if n >= 100:
			tot += n // 100
			n %= 100
		elif n >= 20:
			tot += n // 20
			n %= 20
		elif n >= 10:
			tot += n // 10
			n %= 10
		elif n >= 5:
			tot += n // 5
			n %= 5
		elif n >= 1:
			tot += n
			n %= 1
	print(tot)


a = int(input())
b = a % 10
c = a % 100 - b
s = a // 100 + c // 20 + (c - c // 20 * 20) // 10 + b // 5 + b - b // 5 * 5
print(s)


n = int(input())
f = 0
a = 0
b = 0
c = 0
d = 0
if n >= 100:
	a = n
	a = a % 100
	f = f + (n - a) / 100
	n = n % 100
if n >= 20:
	b = n
	b = b % 20
	f = f + (n - b) / 20
	n = n % 20
if n >= 10:
	c = n
	c = c % 10
	f = f + (n - c) / 10
	n = n % 10
if n >= 5:
	d = n
	d = d % 5
	f = f + (n - d) / 5
	n = n % 5
f = f + n
fin = str(f)
n = fin.find('.')
if n > 0:
	print(fin[0:n])
else:
	print(f)


n = int(input())
arr = [100, 20, 10, 5, 1]
out = 0
for i in range(len(arr)):
	Floor = n // arr[i]
	n = n - Floor * arr[i]
	out = out + Floor
	if not n:
		break
print(out)


n = int(input())
l = 0
a100 = n // 100
a20 = (n - a100 * 100) // 20
a10 = (n - a100 * 100 - a20 * 20) // 10
a5 = (n - a100 * 100 - a20 * 20 - a10 * 10) // 5
a1 = n - a100 * 100 - a20 * 20 - a10 * 10 - a5 * 5
print(a100 + a20 + a10 + a5 + a1)


lst = [100, 20, 10, 5, 1]
num = int(input())
res = 0
for x in lst:
	res += num // x
	num = num % x
print(res)


from bisect import bisect_left
l = [1, 5, 10, 20, 100]
cnt = [0] * 6
n = int(input())
while n:
	ind = bisect_left(l, n)
	if ind <= 4:
		if l[ind] == n:
			cnt[ind] = 1
			n -= n // l[ind] * l[ind]
		else:
			cnt[ind - 1] = n // l[ind - 1]
			n -= n // l[ind - 1] * l[ind - 1]
	else:
		cnt[ind - 1] = n // l[ind - 1]
		n -= n // l[ind - 1] * l[ind - 1]
print(sum(cnt))


n = int(input())
result = int(n / 100)
n = n % 100
result += int(n / 20)
n = n % 20
if n >= 10:
	n -= 10
	result += 1
if n >= 5:
	n -= 5
	result += 1
result += n
print(result)


n = int(input())
tot = 0
arr = [100, 20, 10, 5, 1]
for i in arr:
	(div, rem) = divmod(n, i)
	n = rem
	tot += div
	if rem == 0:
		print(tot)
		exit()


N = int(input())
total = 0
div1 = N // 100
N -= 100 * div1
total += div1
div1 = N // 20
N -= 20 * div1
total += div1
div1 = N // 10
N -= 10 * div1
total += div1
div1 = N // 5
N -= 5 * div1
total += div1
total += N
print(total)


l = [1, 5, 10, 20, 100]
n = int(input())
x = 0
for i in range(4, -1, -1):
	p = n // l[i]
	n = n - p * l[i]
	x += p
print(x)


n = int(input())
ans = 0
for b in [100, 20, 10, 5, 1]:
	while n >= b:
		n -= b
		ans += 1
print(ans)


n = int(input())
d100 = n // 100
n = n % 100
d20 = n // 20
n = n % 20
d10 = n // 10
n = n % 10
d5 = n // 5
n = n % 5
print(d100 + d20 + d10 + d5 + n)


total = int(input())
ticker = 0
while total != 0:
	num = total / 100
	if int(num) > 0:
		total = total - 100 * int(num)
		ticker = ticker + int(num)
	num = total / 20
	if int(num) > 0:
		total = total - 20 * int(num)
		ticker = ticker + int(num)
	num = total / 10
	if int(num) > 0:
		total = total - 10 * int(num)
		ticker = ticker + int(num)
	num = total / 5
	if int(num) > 0:
		total = total - 5 * int(num)
		ticker = ticker + int(num)
	num = total / 1
	if int(num) > 0:
		total = total - 1 * int(num)
		ticker = ticker + int(num)
print(ticker)


def main():
	n = int(input())
	res = 0
	tmp = 0
	if n // 100 > 0:
		tmp = n // 100
		res += tmp
		n = n - tmp * 100
	if n // 20 > 0:
		tmp = n // 20
		res += tmp
		n = n - tmp * 20
	if n // 10 > 0:
		tmp = n // 10
		res += tmp
		n = n - tmp * 10
	if n // 5 > 0:
		tmp = n // 5
		res += tmp
		n = n - tmp * 5
	if n // 1 > 0:
		tmp = n // 1
		res += tmp
		n = n - tmp * 1
	print(res)
main()


n = int(input())
h = n // 100
t20 = int(n % 100 / 20)
t10 = int(n % 20 / 10)
t5 = int(n % 10 / 5)
t1 = int(n % 5 / 1)
print(h + t20 + t10 + t5 + t1)


money = int(input())
k = 0
k += money // 100
money = money % 100
k += money // 20
money = money % 20
k += money // 10
money = money % 10
k += money // 5
money = money % 5
k += money // 1
print(k)


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 = iinput()
count = 0
if n >= 100:
	count += n // 100
	n = n % 100
if n >= 20:
	count += n // 20
	n = n % 20
if n >= 10:
	count += n // 10
	n = n % 10
if n >= 5:
	count += n // 5
	n = n % 5
if n >= 1:
	count += n
	n = 0
print(count)


a = int(input())
c = (100, 20, 10, 5, 1)
s = 0
for i in c:
	if a:
		s += a // i
		a %= i
s += a
print(s)


money = int(input())
h = int(money / 100)
rh = money % 100
twe = int(rh / 20)
rtwe = rh % 20
ten = int(rtwe / 10)
rten = rtwe % 10
f = int(rten / 5)
o = int(rten % 5)
print(h + twe + ten + f + o)


n = int(input())
denominations = [100, 20, 10, 5, 1]
count = 0
for x in denominations:
	count += int(n / x)
	n = n - x * int(n / x)
print(count)


n = int(input())
counter = 0
counter += n // 100
dec = n // 10 % 10
sing = n % 10
counter += dec // 2
if dec % 2 != 0:
	counter += 1
counter += sing // 5
if sing > 5:
	counter += sing - 5
if sing < 5:
	counter += sing
print(counter)


x = int(input())
k = 0
l = [100, 20, 10, 5, 1]
for i in range(len(l)):
	while x / l[i] >= 1:
		m = x // l[i]
		x = x % l[i]
		k += m
print(k)


import sys, math, collections
from itertools import permutations, combinations

def file():
	sys.stdin = open('input.py', 'r')
	sys.stdout = open('output.py', 'w')

def get_array():
	l = list(map(int, input().split()))
	return l

def main():
	n = int(input())
	c = 0
	if n >= 100:
		temp = math.floor(n / 100)
		c += temp
		n = n - temp * 100
	if n >= 20:
		temp = math.floor(n / 20)
		c += temp
		n = n - temp * 20
	if n >= 10:
		temp = math.floor(n / 10)
		c += temp
		n = n - temp * 10
	if n >= 5:
		temp = math.floor(n / 5)
		c += temp
		n = n - temp * 5
	if n >= 1:
		temp = math.floor(n / 1)
		c += temp
		n = n - temp * 1
	print(c)
main()


a = int(input())
ans = 0
while a > 0:
	if a >= 100:
		ans = ans + a // 100
		a = a % 100
	if a >= 20 and a < 100:
		ans = ans + a // 20
		a = a % 20
	if a >= 10 and a < 20:
		ans = ans + a // 10
		a = a % 10
	if a >= 5 and a < 10:
		ans = ans + a // 5
		a = a % 5
	if a >= 1 and a < 5:
		ans = a + ans
		a = a % 1
print(ans)


def solve(n):
	bills = [100, 20, 10, 5, 1]
	num = 0
	for i in bills:
		num += n // i
		n %= i
	return num
n = int(input())
answer = solve(n)
print(answer)


n = int(input())
denominations = [100, 20, 10, 5, 1]
no_of_bills = 0
for item in denominations:
	if n >= item:
		if n % item == 0:
			no_of_bills += n // item
			break
		else:
			no_of_bills += n // item
			n -= item * (n // item)
print(no_of_bills)


a = input()
i = a
dollar_bills = 0
money = int(i)
dollar_bills = money // 100
money = money % 100
dollar_bills += money // 20
money = money % 20
dollar_bills += money // 10
money = money % 10
dollar_bills += money // 5
money = money % 5
dollar_bills += money // 1
money = money % 1
print(dollar_bills)


n = int(input())
o = n // 100 + n % 100 // 20 + n % 100 % 20 // 10 + n % 100 % 20 % 10 // 5 + n % 100 % 20 % 10 % 5
print(o)


n = int(input())
z = 0
while n >= 1:
	if n >= 100:
		z += n // 100
		n = n % 100
	elif n >= 20:
		z += n // 20
		n = n % 20
	elif n >= 10:
		z += n // 10
		n = n % 10
	elif n >= 5:
		z += n // 5
		n = n % 5
	else:
		z += n
		break
print(z)


n = int(input())
l = [1, 5, 10, 20, 100]
index = -1
ans = 0
while n != 0:
	ans += n // l[index]
	n = n % l[index]
	index -= 1
print(ans)


n = int(input())
values = [100, 20, 10, 5, 1]
counter = 0
cur_in = 0
while n != 0:
	if n // values[cur_in] >= 0:
		counter += n // values[cur_in]
		n -= n // values[cur_in] * values[cur_in]
	cur_in += 1
print(counter)


n = int(input())
ans = 0
curr = n // 100
ans += curr
n -= curr * 100
curr = n // 20
ans += curr
n -= curr * 20
curr = n // 10
ans += curr
n -= curr * 10
curr = n // 5
ans += curr
n -= curr * 5
ans += n
print(ans)


coin = [100, 20, 10, 5, 1]
n = int(input())
c = 0
while n > 0:
	for i in coin:
		c += n // i
		n = n % i
print(c)


remain = count = 0

def dhun(n):
	count = int(n / 100)
	remain = n % 100
	return (count, remain)

def dtwen(n):
	count = int(n / 20)
	remain = n % 20
	return (count, remain)

def dten(n):
	count = int(n / 10)
	remain = n % 10
	return (count, remain)

def dfive(n):
	count = int(n / 5)
	remain = n % 5
	return (count, remain)

def done(n):
	count = int(n / 1)
	return count
n = int(input())
bill = 0
(b, r) = dhun(n)
bill += b
if r == 0:
	print(bill)
else:
	(b, r) = dtwen(r)
	bill += b
	if r == 0:
		print(bill)
	else:
		(b, r) = dten(r)
		bill += b
		if r == 0:
			print(bill)
		else:
			(b, r) = dfive(r)
			bill += b
			if r == 0:
				print(bill)
			else:
				b = done(r)
				bill += b
				print(bill)


money = int(input())
coin = 0
if money % 100 != money:
	coin += money // 100
	money %= 100
if money % 20 != money:
	coin += money // 20
	money %= 20
if money % 10 != money:
	coin += money // 10
	money %= 10
if money % 5 != money:
	coin += money // 5
	money %= 5
print(money + coin)


import sys
import math
bank = int(input())
denominations = [100, 20, 10, 5, 1]
bills = 0

def denominate(denom):
	global bank
	global bills
	if bank >= denom:
		billsWithdrawn = math.floor(bank / denom)
		totalWithdrawn = billsWithdrawn * denom
		bank -= totalWithdrawn
		bills += billsWithdrawn
for elem in denominations:
	denominate(elem)
print(bills)


coin = [100, 20, 10, 5, 1]
amount = int(input())
count = 0
rem = 1
while rem != 0:
	for i in range(0, 5):
		rem = amount % coin[i]
		if rem == 0:
			count += amount // coin[i]
			break
		elif rem < amount:
			count += amount // coin[i]
			amount = amount % coin[i]
print(count)


n = int(input())
c = n
sum = 0
sum += int(c / 100)
c %= 100
sum += int(c / 20)
c = c % 20
sum += int(c / 10)
c = c % 10
sum += int(c / 5)
c = c % 5
sum += c / 1
print(int(sum))


n = int(input())
i = 0
c = 0
X = [100, 20, 10, 5, 1]
while n > 0:
	c = c + n // X[i]
	n = n % X[i]
	i = i + 1
print(c)


def count_bill(n, bill, numb):
	while n >= 1:
		if n // 100 != 0:
			bill += n // 100
			n = n % 100
		elif n // 20 != 0:
			bill += n // 20
			n = n % 20
		elif n // 10 != 0:
			bill += n // 10
			n = n % 10
		elif n // 5 != 0:
			bill += n // 5
			n = n % 5
		elif n // 1 != 0:
			bill += n // 1
			n = n % 1
		else:
			continue
	return bill
numb = input()
n = int(numb)
bill = 0
print(count_bill(n, bill, numb))


amount = input()
amount = int(amount)
count = 0
(c1, c3, c4, c5, c6) = (0, 0, 0, 0, 0)
while amount != 0:
	if amount >= 100:
		c1 = amount // 100
		amount = amount % 100
	elif amount >= 20:
		c3 = amount // 20
		amount = amount % 20
	elif amount >= 10:
		c4 = amount // 10
		amount = amount % 10
	elif amount >= 5:
		c5 = amount // 5
		amount = amount % 5
	else:
		c6 = amount // 1
		amount = amount % 1
count = c1 + c3 + c4 + c5 + c6
print(count)


l = [100, 20, 10, 5, 1]
check = int(input())
ans = 0
for i in l:
	ans += int(check / i)
	check = check % i
	if check == 0:
		break
print(ans)


n = int(input())
cont = 0
cont += int(n / 100)
n = n % 100
cont += int(n / 20)
n = n % 20
cont += int(n / 10)
n = n % 10
cont += int(n / 5)
n = n % 5
cont += n
print(cont)


x = int(input())
a = x // 100
b = x % 100
c = b // 20
d = b % 20
e = d // 10
f = d % 10
g = f // 5
h = f % 5
print(a + c + e + g + h)


n = int(input())
y = 0
y = n // 100
n = n % 100
y = y + n // 20
n = n % 20
y = y + n // 10
n = n % 10
y = y + n // 5
n = n % 5
y = y + n // 1
print(y)


money = int(input())
w = 0
w += money // 100
money = money % 100
w += money // 20
money = money % 20
w += money // 10
money = money % 10
w += money // 5
money = money % 5
w += money // 1
money = money % 1
print(w)


def solve(n, dollars):
	count = 0
	while n > 0:
		for e in dollars:
			if e <= n:
				count += n // e
				n %= e
	return count
n = int(input())
dollars = [100, 20, 10, 5, 1]
print(solve(n, dollars))


moneys = int(input())
ans = 0
ans += moneys // 100
moneys = moneys % 100
ans += moneys // 20
moneys = moneys % 20
ans += moneys // 10
moneys = moneys % 10
ans += moneys // 5
moneys = moneys % 5
ans += moneys
print(ans)


n = int(input())
L = [5, 10, 20]

def recur(n, ans=0):
	if n < 5:
		ans += n
		return ans
	if n >= 5 and n < 100:
		lis = []
		for elt in L:
			if n // elt == 0:
				lis.append(100)
			else:
				lis.append(n // elt)
		index = lis.index(min(lis))
		ans += min(lis)
		return recur(n % L[index], ans)
	else:
		return recur(n % 100, n // 100)
print(recur(n))


p = int(input())
q = r = s = t = 0
r = p // 100
s = s + r
p = p - r * 100
r = p // 20
s = s + r
p = p - r * 20
r = p // 10
s = s + r
p = p - r * 10
r = p // 5
s = s + r
p = p - r * 5
r = p // 1
s = s + r
p = p - r * 1
print(s)


x = input()
x = int(x)
f = 0
hundred = 0
twenty = 0
ten = 0
five = 0
one = 0
hundred = int(x / 100)
x = x % 100
twenty = int(x / 20)
x -= 20 * twenty
ten = int(x / 10)
x -= 10 * ten
five = int(x / 5)
x -= 5 * five
one = int(x)
x -= one
f = hundred + twenty + ten + five + one
print(f)


import os
import sys
from io import BytesIO, IOBase
input = sys.stdin.readline

def inp():
	return int(input())

def inlt():
	return list(map(int, input().split()))

def insr():
	s = input()
	return list(s[:len(s) - 1])

def invr():
	return map(int, input().split())
from math import floor, inf

def main():
	try:
		n = inp()
		bills = [1, 5, 10, 20, 100]
		ans = 0
		for i in bills[::-1]:
			ans += n // i
			n = n - n // i * i
		print(ans)
	except Exception as e:
		print(e)
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):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		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))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
main()


import sys
from functools import lru_cache, cmp_to_key
from heapq import merge, heapify, heappop, heappush, nlargest, nsmallest, _heapify_max, _heapreplace_max
from math import ceil, floor, gcd, fabs, factorial, fmod, sqrt, inf, log
from collections import defaultdict as dd, deque, Counter as c
from itertools import combinations as comb, permutations as perm
from bisect import bisect_left as bl, bisect_right as br, bisect
from fractions import Fraction
mod = pow(10, 9) + 7
mod2 = 998244353

def data():
	return sys.stdin.readline().strip()

def out(*var, end='\n'):
	sys.stdout.write(' '.join(map(str, var)) + end)

def l():
	return list(sp())

def sl():
	return list(ssp())

def sp():
	return map(int, data().split())

def ssp():
	return map(str, data().split())

def l1d(n, val=0):
	return [val for i in range(n)]

def l2d(n, m, val=0):
	return [l1d(n, val) for j in range(m)]
n = int(data())
arr = [100, 20, 10, 5, 1]
answer = 0
for i in arr:
	answer += n // i
	n -= i * (n // i)
	if n <= 0:
		break
out(answer)


n = int(input())
req = [100, 20, 10, 5, 1]
ans = 0
a = int(n / 100)
ans += a
n = n % 100
a = int(n / 20)
ans += a
n = n % 20
a = int(n / 10)
ans += a
n = n % 10
a = int(n / 5)
ans += a
n = n % 5
a = int(n / 1)
ans += a
print(ans)


count = int(input())
act1 = count // 100
changeAct1 = count % 100
act2 = changeAct1 // 20
changeAct2 = changeAct1 % 20
act3 = changeAct2 // 10
changeAct3 = changeAct2 % 10
act4 = changeAct3 // 5
changeAct4 = changeAct3 % 5
act5 = changeAct4 // 1
changeAct5 = changeAct4 % 1
n = act1 + act2 + act3 + act4 + act5
print(n)


n = int(input())
bill = 0
bill += n // 100
n = n % 100
bill += n // 20
n = n % 20
bill += n // 10
n = n % 10
bill += n // 5
n = n % 5
bill += n // 1
print(bill)


from sys import stdin

def solve():
	n = int(input())
	A = [100, 20, 10, 5, 1]
	i = 0
	c = 0
	while n != 0:
		while n >= A[i]:
			n -= A[i]
			c += 1
		i += 1
	print(c)
solve()


value = int(input())
values = [100, 20, 10, 5, 1]
count = 0
for i in values:
	count += value // i
	value = value % i
print(count)


n = int(input())
bills = [100, 20, 10, 5, 1]
count = 0
for b in bills:
	amount = int(n / b)
	n -= amount * b
	count += amount
print(count)


n = int(input())
bils = 0
if n / 100 >= 1:
	bils += int(n / 100)
	n %= 100
if n / 20 >= 1:
	bils += int(n / 20)
	n %= 20
if n / 10 >= 1:
	bils += int(n / 10)
	n %= 10
if n / 5 >= 1:
	bils += int(n / 5)
	n %= 5
if n >= 1:
	bils += n
print(bils)


def getMinTotalBills(money: int):
	sw = -1
	denoms = [100, 20, 10, 5, 1]
	EA = []
	for denom in denoms:
		sw *= -1
		ea = int(money / denom)
		EA.append(ea)
		money = money - ea * denom
		if sw == 1:
			denom /= 5
		elif sw == -1:
			denom /= 2
	return sum(EA)
money = int(input())
print(getMinTotalBills(money))


money = int(input())
bills = money // 100
money %= 100
bills += money // 20
money %= 20
bills += money // 10
money %= 10
bills += money // 5
money %= 5
bills += money // 1
money %= 1
print(bills)


cash = input()
cash = int(cash)
bill = 0
bill += cash // 100
cash %= 100
bill += cash // 20
cash %= 20
bill += cash // 10
cash %= 10
bill += cash // 5
cash %= 5
bill += cash
print(bill)


a = input()
a = int(a)
b = a // 100
c = a % 100
d = c // 20
e = c % 20
k = e // 10
p = e % 10
m = p // 5
x = p % 5
y = x // 1
z = b + d + k + m + y
print(z)


d = int(input())
c100 = (d - d % 100) / 100
d = d - 100 * c100
c20 = (d - d % 20) / 20
d = d - 20 * c20
c10 = (d - d % 10) / 10
d = d - 10 * c10
c5 = (d - d % 5) / 5
d = d - 5 * c5
i = c100 + c20 + c10 + c5 + d % 5
print(int(i))


n = int(input())
j = 0
a = [100, 20, 10, 5, 1]
k = 0
while n > 0:
	x = n // a[j]
	if x == 0:
		j += 1
	else:
		k += x
		n -= x * a[j]
print(k)


n = int(input())
l = [1, 5, 10, 20, 100]
j = 0
k = 0
for i in range(4, -1, -1):
	if n >= l[i]:
		k = n // int(l[i])
		n = n % l[i]
		j = j + k
		if n == 0:
			break
print(j)


n = int(input())
coins = [1, 5, 10, 20, 100]
count = 0

def get_max_coin(n):
	for coin in coins[::-1]:
		if coin <= n:
			return coin
tmp = 0
while n != 0:
	tmp = get_max_coin(n)
	n -= tmp
	count += 1
print(count)


a = int(input())
dn = [100, 20, 10, 5, 1]
bills = 0
for i in dn:
	f = True
	while f:
		if a >= i:
			c = int(a / i)
			a -= c * i
			bills += c
		else:
			f = False
print(bills)


from math import floor
N = int(input())
k = 0
k += floor(N / 100)
N %= 100
k += floor(N / 20)
N %= 20
k += floor(N / 10)
N %= 10
k += floor(N / 5)
N %= 5
k += floor(N / 1)
print(k)


m = int(input())
counter = 0
if m >= 100:
	counter += int(m / 100)
	m -= int(m / 100) * 100
if m >= 20:
	counter += int(m / 20)
	m -= int(m / 20) * 20
if m >= 10:
	counter += int(m / 10)
	m -= int(m / 10) * 10
if m >= 5:
	counter += int(m / 5)
	m -= int(m / 5) * 5
counter += m
print(counter)


n = input()
a = [0] * len(n)
for i in range(len(n)):
	a[i] = n[i] + n[i:len(n) - 1].replace(n[i:len(n) - 1], '0' * (len(n) - (i + 1)))
b = 0
for i in range(len(n)):
	if len(a[i]) >= 3:
		b += int(int(a[i]) / 100)
	if len(a[i]) == 2 and int(a[i]) % 20 != 0:
		b += int(int(a[i]) / 20) + (int(int(a[i]) / 10) - 2 * int(int(a[i]) / 20))
	if len(a[i]) == 2 and int(a[i]) % 20 == 0:
		b += int(int(a[i]) / 20)
	if len(a[i]) == 1 and int(a[i]) % 5 != 0:
		b += int(int(a[i]) / 5) + (int(int(a[i]) / 1) - 5 * int(int(a[i]) / 5))
	if len(a[i]) == 1 and int(a[i]) % 5 == 0:
		b += int(int(a[i]) / 5)
print(b)


def solve():
	cs = [100, 20, 10, 5, 1]
	n = int(input())
	ans = 0
	for c in cs:
		ans += n // c
		n %= c
	print(ans)
solve()


from collections import deque
from collections import OrderedDict
import math
import sys
import os
import threading
import bisect
import operator
import heapq
from atexit import register
from io import BytesIO
import io
input = lambda : sys.stdin.readline().rstrip('\r\n')
n = int(input())
dp = [999999] * 120
dp[0] = 0
arV = [1, 5, 10, 20, 100]
for i in range(len(arV)):
	dp[arV[i]] = 1
for i in range(1, 105):
	for j in range(len(arV)):
		if arV[j] > i:
			break
		dp[i] = min(dp[i - arV[j]] + 1, dp[i])
answer = n // 100 + dp[n % 100]
print(answer)


a = int(input())
liczba_banknotow = 0
for x in [100, 20, 10, 5, 1]:
	liczba_banknotow += a // x
	a = a % x
print(liczba_banknotow)


def lottery1():
	n = int(input())
	values = [100, 20, 10, 5, 1]
	j = 0
	i = 0
	while n != 0:
		while n < values[i]:
			i += 1
		j += n // values[i]
		n -= values[i] * (n // values[i])
		i += 1
	return j
print(lottery1())


import sys
from collections import *
from math import *
import re

def sieve(n):
	prime = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	c = 0
	for i in range(2, n):
		if prime[i]:
			c += 1
	return c

def iseven(n):
	return [False, True][0 if n % 2 else 1]

def inp_arr():
	return list(map(int, input().split()))

def inp():
	return map(int, input().split())

def lcm(a, b):
	return a * b / gcd(a, b)
max_int = sys.maxsize
mod = 10 ** 9 + 7
n = int(input())
arr = [1, 5, 10, 20, 100]
c = 0
i = len(arr) - 1
while i >= 0 and n > 0:
	if n < arr[i]:
		i -= 1
		continue
	c += n // arr[i]
	n = n % arr[i]
	i -= 1
print(c)


import math
n = int(input())
count = 0
if n <= 0:
	print(0)
else:
	while n > 0:
		if n >= 100:
			count += math.trunc(n / 100)
			n = n - math.trunc(n / 100) * 100
		elif 20 <= n < 100:
			count += math.trunc(n / 20)
			n = n - math.trunc(n / 20) * 20
		elif 10 <= n < 20:
			count += math.trunc(n / 10)
			n = n - math.trunc(n / 10) * 10
		elif 5 <= n < 10:
			count += math.trunc(n / 5)
			n = n - math.trunc(n / 5) * 5
		elif 1 <= n < 5:
			count += math.trunc(n / 1)
			n = n - math.trunc(n / 1) * 1
print(count)


def solve(c):
	can = [100, 20, 10, 5, 1]
	ans = 0
	for i in can:
		if c >= i:
			this_step = c // i
			ans += this_step
			c = abs(i * this_step - c)
	return ans
print(solve(int(input())))


n = int(input())
m = n // 100
n = n % 100
m = m + n // 20
n = n % 20
m = m + n // 10
n = n % 10
m = m + n // 5
n = n % 5
m = m + n // 1
print(m)


def sub(c, s, n):
	y = int(n / s)
	x = n - y * s
	z = y + c
	return (z, x)
(a, b) = sub(0, 100, int(input()))
(c, d) = sub(a, 20, b)
(e, f) = sub(c, 10, d)
(g, h) = sub(e, 5, f)
(i, j) = sub(g, 1, h)
print(i)


arr = [100, 20, 10, 5, 1]
pos = 0
n = int(input())
ite = 0
while n > 0:
	ite += n // arr[pos]
	n = n % arr[pos]
	pos += 1
print(ite)


def function01(dollars):
	count = 0
	for i in [100, 20, 10, 5, 1]:
		bills = dollars // i
		count = count + bills
		dollars = dollars % i
	return count
print(function01(int(input())))


from math import floor
n = int(input())
print(int(floor(n / 100) + floor(n % 100 / 20) + floor(n % 20 / 10) + floor(n % 10 / 5) + floor(n % 5)))


num = int(input())
num1 = num // 100
num = num - num1 * 100
num2 = num // 20
num = num - num2 * 20
num3 = num // 10
num = num - num3 * 10
num4 = num // 5
num = num - num4 * 5
count = num1 + num2 + num3 + num4 + num
print(count)


num = int(input())
count = 0
output = num // 100 + num % 100 // 20 + num % 100 % 20 // 10 + num % 100 % 20 % 10 // 5 + num % 100 % 20 % 10 % 5 // 1
print(output)


amount = int(input())
print(amount // 100 + amount % 100 // 20 + amount % 20 // 10 + amount % 10 // 5 + amount % 5)


n = int(input())
t = 0
if n == 1 or n == 5 or n == 10 or (n == 20) or (n == 100):
	print(1)
else:
	while n != 0:
		if n >= 100:
			n = n - 100
			t += 1
		elif n >= 20:
			n = n - 20
			t += 1
		elif n >= 10:
			n = n - 10
			t += 1
		elif n >= 5:
			n = n - 5
			t += 1
		elif n >= 1:
			n = n - 1
			t += 1
	print(t)


money = int(input())
counter = 0
while money >= 100:
	counter += 1
	money -= 100
while money >= 20:
	counter += 1
	money -= 20
while money >= 10:
	counter += 1
	money -= 10
while money >= 5:
	counter += 1
	money -= 5
while money >= 1:
	counter += 1
	money -= 1
print(counter)


a = int(input())
notes = 0
if a >= 100:
	notes += a // 100
	a %= 100
if a >= 20:
	notes += a // 20
	a %= 20
if a >= 10:
	notes += a // 10
	a %= 10
if a >= 5:
	notes += a // 5
	a %= 5
if a >= 1:
	notes += a // 1
	a = 0
print(notes)


n = int(input())
a = n // 100
r = n % 100 // 20
c = n % 20 // 10
l = n % 10 // 5
b = n % 5 // 1
f = l + c + r + a + b
print(f)


coins = [1, 5, 10, 20, 100]
n = int(input())

def f(n):
	global coins
	if n == 0:
		return 0
	for coin in coins:
		if coin <= n:
			min_coin = n // coin + f(n % coin)
	return min_coin
print(f(n))


import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, random, time, queue, copy
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
mod = 10 ** 9 + 7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]

def LI():
	return [int(x) for x in sys.stdin.readline().split()]

def LI_():
	return [int(x) - 1 for x in sys.stdin.readline().split()]

def I():
	return int(sys.stdin.readline())

def LS():
	return sys.stdin.readline().split()

def S():
	return input()

def main():
	n = I()
	c = 0
	while True:
		if n >= 100:
			c += n // 100
			n %= 100
		elif n >= 20:
			c += n // 20
			n %= 20
		elif n >= 10:
			c += n // 10
			n %= 10
		elif n >= 5:
			c += n // 5
			n %= 5
		elif n >= 1:
			c += n // 1
			n %= 1
		if n == 0:
			return c
print(main())


balance = int(input())
denominations = [1, 5, 10, 20, 100]
denominations.reverse()
count = 0
while balance > 0:
	for bill in denominations:
		if balance >= bill:
			bill_count = (balance - balance % bill) // bill
			balance = balance - bill_count * bill
			count = count + bill_count
print(count)


money = int(input())
bills = [100, 20, 10, 5, 1]
res = 0
for b in bills:
	if money >= b:
		n = money // b
		money -= b * n
		res += n
print(res)


i = int(input().strip())
c = i
count = 0
while c != 0:
	if int(c // 100) != 0:
		count = count + int(c // 100)
		c = c % 100
		continue
	if int(c // 20) != 0:
		count = count + int(c // 20)
		c = c % 20
		continue
	if int(c // 10) != 0:
		count = count + int(c // 10)
		c = c % 10
		continue
	if int(c // 5) != 0:
		count = count + int(c // 5)
		c = c % 5
		continue
	count = count + c
	c = 0
print(count)


n = int(input())
A = [100, 20, 10, 5, 1]
num = 0
for i in range(5):
	if n == 0:
		break
	num += n // A[i]
	n -= A[i] * (n // A[i])
print(num)


n = int(input())
k = 0
t = 0
if n >= 100:
	t = n // 100
	k = k + t
	n = n - 100 * t
if n >= 20:
	t = n // 20
	k = k + t
	n = n - 20 * t
if n >= 10:
	t = n // 10
	k = k + t
	n = n - 10 * t
if n >= 5:
	t = n // 5
	k = k + t
	n = n - 5 * t
if n >= 1:
	t = n // 1
	k = k + t
	n = n - 1 * t
print(k)


cnt = 0
tot = 0
n = int(input())
notes = [100, 20, 10, 5, 1]
while n > 0:
	if notes[cnt] <= n:
		n -= notes[cnt]
		tot += 1
	else:
		cnt += 1
print(tot)


import math
dollar = 0
n = int(input())
while n > 0:
	if n / 100 >= 1:
		dollar += math.floor(n / 100)
		n %= 100
	elif n / 20 >= 1:
		dollar += math.floor(n / 20)
		n %= 20
	elif n / 10 >= 1:
		dollar += math.floor(n / 10)
		n %= 10
	elif n / 5 >= 1:
		dollar += math.floor(n / 5)
		n %= 5
	elif n / 1 >= 1:
		dollar += math.floor(n)
		break
print(int(dollar))


from math import inf
n = int(input())
minBills = 0
while n > 0:
	if n - 100 >= 0:
		n = n - 100
		minBills += 1
	elif n - 20 >= 0:
		n = n - 20
		minBills += 1
	elif n - 10 >= 0:
		n = n - 10
		minBills += 1
	elif n - 5 >= 0:
		n = n - 5
		minBills += 1
	elif n - 1 >= 0:
		n = n - 1
		minBills += 1
print(minBills)


arr = [100, 20, 10, 5, 1]
inp = int(input())
i = 0
count = 0
while inp != 0:
	if inp % arr[i] <= inp:
		count = count + inp // arr[i]
		inp = inp % arr[i]
	i += 1
print(count)


a = int(input())
n100 = a // 100
r100 = a % 100
n20 = r100 // 20
r20 = r100 % 20
n10 = r20 // 10
r10 = r20 % 10
n5 = r10 // 5
r5 = r10 % 5
print(n100 + n20 + n10 + n5 + r5)


n = int(input())
temp = int(n / 100)
n = n % 100
temp += int(n / 20)
n = n % 20
temp += int(n / 10)
n = n % 10
temp += int(n / 5)
n = n % 5
temp += n
print(temp)


import math as m
money = int(input())
note_sum = 0
notes = [100, 20, 10, 5, 1]
for note in notes:
	if money > 0:
		if money < note:
			continue
		if money == note or money % note == 0:
			note_sum += money / note
			money = 0
		if money >= note and money % note != 0:
			note_sum += m.floor(money / note)
			money = money % note
print(int(note_sum))


n = int(input())
(s, m) = (0, 0)
s = int(n / 100)
m = n % 100
s = s + int(m / 20)
m = m % 20
s = s + int(m / 10)
m = m % 10
s = s + int(m / 5)
m = m % 5
s = s + m
print(s)


s = 0
money = int(input())
if money >= 100:
	s += money // 100
	money -= 100 * s
if money >= 20:
	q = money // 20
	s += q
	money -= 20 * q
if money >= 10:
	q = money // 10
	s += q
	money -= 10 * q
if money >= 5:
	q = money // 5
	s += q
	money -= 5 * q
if money >= 1:
	q = money
	s += q
	money -= 20 * q
print(str(s))


import math as mth
v = int(input())
a = [100, 20, 10, 5, 1]
c = 0
for i in a:
	if v >= i:
		c += mth.floor(v / i)
		v = v % i
print(c)


n = int(input())
arr = [100, 20, 10, 5, 1]
count = 0
while n != 0:
	for i in arr:
		div = n // i
		n = n % i
		count += div
print(count)


import sys
input = sys.stdin.readline

def inp():
	return int(input())

def inlt():
	return list(map(int, input().split()))

def insr():
	s = input()
	return list(s[:len(s) - 1])

def invr():
	return map(int, input().split())
n = inp()
s = [1, 5, 10, 20, 100]
b = 0
while n != 0:
	if n < 100:
		for i in range(1, 5):
			if s[i] > n:
				b += 1
				n -= s[i - 1]
				break
	else:
		b += 1
		n -= 100
print(b)


bills = [100, 20, 10, 5, 1]
n = int(input())
bills_count = 0
i = 0
while n != 0:
	if n - bills[i] >= 0:
		n -= bills[i]
		bills_count += 1
	else:
		i += 1
print(bills_count)


sum = int(input())
number = 0
if sum // 100 > 0:
	number += sum // 100
	sum %= 100
if sum // 20 > 0:
	number += sum // 20
	sum %= 20
if sum // 10 > 0:
	number += sum // 10
	sum %= 10
if sum // 5 > 0:
	number += sum // 5
	sum %= 5
if sum // 1 > 0:
	number += sum // 1
print(number)


bills = [100, 20, 10, 5, 1]
n = int(input())
output = 0
for bill in bills:
	mayorDivisor = n // bill
	if mayorDivisor > 0:
		n = n - bill * mayorDivisor
		output += mayorDivisor
print(output)


n = int(input())
m = [100, 20, 10, 5, 1]
cur = 0
ans = 0
while n != 0:
	mon = n // m[cur]
	if mon > 0:
		ans += mon
		n %= m[cur]
		cur += 1
	else:
		cur += 1
print(ans)


c = int(input())
ans = int(c / 100)
c -= int(c / 100) * 100
ans += int(c / 20)
c -= int(c / 20) * 20
ans += int(c / 10)
c -= int(c / 10) * 10
ans += int(c / 5)
c -= int(c / 5) * 5
ans += int(c / 1)
c -= int(c / 1) * 1
print(ans)


x = int(input())
total = 0
while x:
	if x >= 100:
		total = total + int(x / 100)
		x = x % 100
	if x >= 20:
		total = total + int(x / 20)
		x = x % 20
	if x >= 10:
		total = total + int(x / 10)
		x = x % 10
	if x >= 5:
		total = total + int(x / 5)
		x = x % 5
	if x >= 1:
		total = total + int(x / 1)
		x = x % 1
print(total)


t = int(input())
count = 0
while t >= 100 and t != 0:
	p = int(t / 100)
	t = t % 100
	count += p
while t >= 20 and t != 0:
	p = int(t / 20)
	t = t % 20
	count += p
while t >= 10 and t != 0:
	p = int(t / 10)
	t = t % 10
	count += p
while t >= 5 and t != 0:
	p = int(t / 5)
	t = t % 5
	count += p
while t >= 1 and t != 0:
	p = int(t)
	count += p
	t = 0
print(count)


n = int(input())
denominations = [100, 20, 10, 5, 1]
coins = 0
for i in range(len(denominations)):
	while n >= denominations[i]:
		coins += n // denominations[i]
		n = n % denominations[i]
print(coins)


p = [100, 20, 10, 5, 1]
n = int(input())
j = 0
for i in p:
	j += n // i
	n %= i
print(j)


n = int(input())
bill_types = [1, 5, 10, 20, 100]
bill_types.reverse()
res = 0
for bill in bill_types:
	res += n // bill
	n = n % bill
print(res)


def main():
	n = int(input())
	bill = 0
	if n >= 100:
		bill += n // 100
		n %= 100
	if n >= 20:
		bill += n // 20
		n %= 20
	if n >= 10:
		bill += n // 10
		n %= 10
	if n >= 5:
		bill += n // 5
		n %= 5
	bill += n
	print(bill)
main()


n = int(input())
(a, n) = divmod(n, 100)
(b, n) = divmod(n, 20)
(c, n) = divmod(n, 10)
(d, n) = divmod(n, 5)
(e, n) = divmod(n, 1)
print(sum([a, b, c, d, e]))


import sys
import math
n = int(input())
doll = n
c = 0
while doll > 0:
	if doll >= 100:
		c += doll // 100
		doll = doll - doll // 100 * 100
	elif doll >= 20:
		c += doll // 20
		doll = doll - doll // 20 * 20
	elif doll >= 10:
		c += doll // 10
		doll = doll - doll // 10 * 10
	elif doll >= 5:
		c += doll // 5
		doll = doll - doll // 5 * 5
	elif doll >= 1:
		c += doll // 1
		doll = doll - doll // 1 * 1
print(c)


suma_deneg = int(input())
kupuri100 = suma_deneg // 100
kupuri20 = suma_deneg % 100 // 20
kupuri10 = suma_deneg % 20 // 10
kupuri5 = suma_deneg % 10 // 5
kupuri1 = suma_deneg % 5 // 1
print(kupuri100 + kupuri20 + kupuri10 + kupuri5 + kupuri1)


bp = int(input())
uc_100 = bp // 100
uc_20 = bp % 100 // 20
uc_10 = bp % 100 % 20 // 10
uc_5 = bp % 100 % 20 % 10 // 5
uc_1 = bp % 100 % 20 % 10 % 5
o = uc_100 + uc_20 + uc_10 + uc_5 + uc_1
print(o)


from _ast import If
from math import floor
num = int(input())
i = 0
i = i + floor(num / 100)
num = num % 100
i = i + floor(num / 20)
num = num % 20
i = i + floor(num / 10)
num = num % 10
i = i + floor(num / 5)
num = num % 5
i = i + num
print(i)


n = int(input())

def lottery(n):
	if n == 0:
		return 0
	if n < 5:
		return n
	if 5 <= n < 10:
		a = n // 5
		b = n % 5
		return a + b
	if 10 <= n < 20:
		a = n // 10
		b = lottery(n % 10)
		return a + b
	if 20 <= n < 100:
		a = n // 20
		b = lottery(n % 20)
		return a + b
	if n >= 100:
		a = n // 100
		b = lottery(n % 100)
		return a + b
print(lottery(n))


n = int(input())
l = [1, 5, 10, 20, 100]
cnt = 0
j = 4
while n > 0:
	i = l[j]
	cnt += int(n / i)
	n = n % i
	j -= 1
print(cnt)


from functools import reduce
denom = [100, 20, 10, 5, 1]

def min_bills(amount):
	result = reduce(lambda x, y: (x[0] % y, x[1] + x[0] // y), denom, (amount, 0))
	return result[1]
amount = int(input())
result = min_bills(amount)
print(result)


n = int(input())
a = [1, 5, 10, 20, 100]
i = 4
flag = 0
x = n
while x != 0:
	flag += x // a[i]
	x = x % a[i]
	i -= 1
print(flag)


n = int(input())
while n >= 0:
	i = n // 100
	n = n % 100
	j = n // 20
	n = n % 20
	k = n // 10
	n = n % 10
	l = n // 5
	n = n % 5
	m = n // 1
	n = n % 1
	break
print(i + j + k + l + m)


num = int(input())
ans = num // 100 + num % 100 // 20 + num % 20 // 10 + num % 10 // 5
ans += num % 5 // 1
print(ans)


arr = [100, 20, 10, 5, 1]
doller = int(input())
j = 0
for i in arr:
	while doller >= i:
		doller -= i
		j += 1
print(j)


n = int(input())
cnt = 0
while n != 0:
	if n >= 1 and n < 5:
		c = n // 1
		cnt = cnt + c
		n = 0
	elif n >= 5 and n < 10:
		c = n // 5
		cnt = cnt + c
		n = n % 5
	elif n >= 10 and n < 20:
		c = n // 10
		cnt = cnt + c
		n = n % 10
	elif n >= 20 and n < 100:
		c = n // 20
		cnt = cnt + c
		n = n % 20
	elif n >= 100:
		c = n // 100
		cnt = cnt + c
		n = n % 100
print(cnt)


totalsum = int(input())
bill = 0
while totalsum > 0:
	if totalsum >= 100:
		bill += int(totalsum / 100)
		totalsum %= 100
	elif totalsum >= 20:
		bill += int(totalsum / 20)
		totalsum %= 20
	elif totalsum >= 10:
		bill += int(totalsum / 10)
		totalsum %= 10
	elif totalsum >= 5:
		bill += int(totalsum / 5)
		totalsum %= 5
	else:
		totalsum -= 1
		bill += 1
print(bill)


n = int(input())
notes = [100, 20, 10, 5, 1]
ans = 0
for note in notes:
	ans = ans + n // note
	n = n % note
print(ans)


n = int(input())
nb = 0
nb += n // 100
n = n % 100
nb += n // 20
n = n % 20
nb += n // 10
n = n % 10
nb += n // 5
n = n % 5
nb += n
print(nb)


coins = [1, 5, 10, 20, 100]
a = int(input())
ans = 0
for i in reversed(coins):
	ans += a // i
	a %= i
print(ans)


def mincoin(c, n, a):
	m = 0
	for i in range(n - 1):
		if a // c[i]:
			m += a // c[i]
			a = a - a // c[i] * c[i]
	return m + a
c = [100, 20, 10, 5, 1]
x = int(input())
n = 5
print(mincoin(c, n, x))


n = int(input())
den = [100, 20, 10, 5, 1]
total = 0
for d in den:
	(bills, new) = divmod(n, d)
	n = new
	total += bills
print(total)


n = int(input())
l = [100, 20, 10, 5, 1]
sum = 0
while n > 0:
	for i in l:
		a = n // i
		n = n % i
		sum = sum + a
print(sum)


from sys import stdin
from math import gcd

def readLine():
	return stdin.readline().strip()

def readInt():
	return int(readLine())

def readInts():
	return list(map(int, readLine().split()))

def main():
	n = readInt()
	bills = [100, 20, 10, 5, 1]
	ans = 0
	for bill in bills:
		if n >= bill:
			d = n // bill
			ans += d
			n -= d * bill
	print(ans)
main()


n = int(input())
l = [100, 20, 10, 5, 1]
c = 0
for i in l:
	m = n // i
	n = n - m * i
	c = c + m
print(c)


x = int(input())
count = 0
for i in range(100000000):
	if x - 10000 >= 0:
		x = x - 10000
		count = count + 100
		continue
	if x - 100 >= 0:
		x = x - 100
		count = count + 1
		continue
	elif x - 20 >= 0:
		x = x - 20
		count = count + 1
		continue
	elif x - 10 >= 0:
		x = x - 10
		count = count + 1
		continue
	elif x - 5 >= 0:
		x = x - 5
		count = count + 1
		continue
	elif x - 1 >= 0:
		x = x - 1
		count = count + 1
		continue
	if x == 0:
		break
print(count)


import math
n = float(input())
ans = math.floor(n / 100)
n -= 100 * ans
ans2 = math.floor(n / 20)
n -= 20 * ans2
ans3 = math.floor(n / 10)
n -= 10 * ans3
ans4 = math.floor(n / 5)
n -= 5 * ans4
ans5 = math.floor(n)
n -= ans5
print(int(ans + ans2 + ans3 + ans4 + ans5))


n = int(input())
a = [100, 20, 10, 5, 1]
x = 0
for i in range(len(a)):
	y = 0
	x += n // a[i]
	y += n // a[i]
	n -= a[i] * y
print(x)


n = int(input())
l = [100, 20, 10, 5, 1]
sm = 0
for i in l:
	x = n % i
	sm += n // i
	n = x
print(sm)


n = int(input())
k = n
ls = [100, 20, 10, 5, 1]
s = i = 0
l = [0] * 5
for i in range(len(ls)):
	a = k // ls[i]
	l[i] = a
	k = n - (l[0] * 100 + l[1] * 20 + l[2] * 10 + l[3] * 5 + l[4] * 1)
print(sum(l))


def denomination(n):
	c = 0
	i = 0
	ls = [100, 20, 10, 5, 1]
	while n > 0:
		if n >= ls[i]:
			c = c + int(n / ls[i])
			n = n % ls[i]
		else:
			i = i + 1
	return c
n = int(input())
print(denomination(n))


denominations = [100, 20, 10, 5, 1]
n = int(input())
ans = 0
for den in denominations:
	temp = n // den * den
	ans += n // den
	n -= temp
print(ans)


c = [100, 20, 10, 5, 1]
n = int(input(''))
ans = 0
for i in range(5):
	if n <= 0:
		break
	inc = n // c[i]
	ans += inc
	n -= inc * c[i]
print(ans)


dollars = int(input())
denoms = [100, 20, 10, 5, 1]
bills = 0
for denom in denoms:
	bills += dollars // denom
	dollars = dollars % denom
print(bills)


n = int(input())
q = 0
q += n // 100
n %= 100
q += n // 20
n %= 20
q += n // 10
n %= 10
q += n // 5
n %= 5
q += n
print(q)


n = int(input())
nob = 0
if n >= 100:
	nob = nob + n // 100
	n = n % 100
if n >= 20:
	nob = nob + n // 20
	n = n % 20
if n >= 10:
	nob = nob + n // 10
	n = n % 10
if n >= 5:
	nob = nob + n // 5
	n = n % 5
if n >= 1:
	nob = nob + n // 1
	n = n % 20
print(nob)


import bisect
n = int(input())
l = [1, 5, 10, 20, 100]
c = 0
while 1:
	if n == 0:
		break
	else:
		v = bisect.bisect(l, n)
		c = c + n // l[v - 1]
		n = n % l[v - 1]
print(c)


n = int(input())
notes = 0
remaining = 0
for i in [100, 20, 10, 5, 1]:
	if n >= i:
		notes += n // i
		n = n % i
		if n == 0:
			break
print(notes)


n = int(input())
arr = [1, 5, 10, 20, 100]
ans = 0
if n > 100:
	ans = int(n / 100)
	n = n % 100
dp = [[0] * (n + 1)] * 6
for i in range(1, 6):
	for j in range(1, n + 1):
		if arr[i - 1] == j:
			dp[i][j] = 1
			continue
		if arr[i - 1] > j:
			dp[i][j] = dp[i - 1][j]
			continue
		if arr[i - 1] < j:
			dp[i][j] = 1 + dp[i][j - arr[i - 1]]
			continue
print(ans + dp[5][n])


import sys

def minCoins(coins, m, V):
	table = [0 for i in range(V + 1)]
	table[0] = 0
	for i in range(1, V + 1):
		table[i] = sys.maxsize
	for i in range(1, V + 1):
		for j in range(m):
			if coins[j] <= i:
				sub_res = table[i - coins[j]]
				if sub_res != sys.maxsize and sub_res + 1 < table[i]:
					table[i] = sub_res + 1
	return table[V]
coins = [1, 5, 10, 20, 100]
m = len(coins)
V = int(input())
if V < 10000:
	print(minCoins(coins, m, V))
else:
	ans = 0
	a = V % 100
	b = a % 20
	c = b % 10
	d = c % 5
	ans = V // 100 + a // 20 + b // 10 + c // 5 + d
	print(ans)


n = int(input())
a = ['100', '20', '10', '5', '1']
j = 0
count = 0
for i in a:
	if n >= int(i):
		j = n // int(i)
		n = n - j * int(i)
		count += j
print(count)


n = int(input())
hundred = n // 100
n = n - hundred * 100
twenty = n // 20
n = n - twenty * 20
ten = n // 10
n = n - ten * 10
five = n // 5
n = n - five * 5
one = n // 1
n = n - one * 1
print(f'{hundred + twenty + ten + five + one}')


n = int(input())
count = 0
while n >= 100000:
	n = n - 100000
	count += 1000
while n >= 100:
	n = n - 100
	count += 1
while n >= 20:
	n = n - 20
	count += 1
while n >= 10:
	n = n - 10
	count += 1
while n >= 5:
	n = n - 5
	count += 1
while n >= 1:
	n = n - 1
	count += 1
print(count)


a = int(input())
run = True
c = 0
while run:
	if a >= 100:
		c = c + int(a / 100)
		a = a % 100
	elif a >= 20 and a < 100:
		c = c + int(a / 20)
		a = a % 20
	elif a >= 10 and a < 20:
		c = c + int(a / 10)
		a = a % 10
	elif a >= 5 and a < 10:
		c = c + int(a / 5)
		a = a % 5
	elif a >= 1 and a < 5:
		c = c + int(a / 1)
		a = a % 1
	if a == 0:
		run = False
print(c)


x = int(input())
a = [1, 5, 10, 20, 100]
i = 4
f = 0
while x != 0:
	re = x // a[i]
	x = x % a[i]
	f = f + re
	i = i - 1
print(f)


n = int(input())
coins = [100, 20, 10, 5]
rem = n
count = 0
for i in coins:
	count += rem // i
	rem = rem % i
count += rem
print(count)


userInput = int(input())
coins = [100, 20, 10, 5, 1]
count = 0
for i in range(5):
	if coins[i] <= userInput:
		d = userInput // coins[i]
		count += d
		userInput -= d * coins[i]
print(count)


def minimum_bills(amount):
	denom = [100, 20, 10, 5, 1]
	num_bills = 0
	for i in range(0, 5):
		bill_value = denom[i]
		floor = amount // bill_value
		amount %= bill_value
		num_bills += floor
	return num_bills
amount = int(input())
print(minimum_bills(amount))


deno = [100, 20, 10, 5, 1]
amount = int(input())
bills = 0
for i in deno:
	if amount >= i:
		curr = amount // i
		bills += curr
		amount -= curr * i
		if amount == 0:
			break
print(bills)


def getBills(n):
	denominations = [100, 20, 10, 5, 1]
	bills = 0
	for item in denominations:
		if n >= item:
			bills += n // item
			n -= n // item * item
	return bills
n = int(input())
print(getBills(n))


amount = int(input())
bills = 0
notes = [100, 20, 10, 5, 1]
while amount > 0:
	if amount >= notes[0]:
		bills += amount // notes[0]
		amount %= notes[0]
	notes.pop(0)
print(bills)


denominations = [100, 20, 10, 5, 1]
money = int(input())
bills = []
remainder = 0
if money % denominations[0] != 0:
	bills.append(money // denominations[0])
	remainder = money % denominations[0]
elif money % denominations[0] == 0:
	bills.append(money // denominations[0])
if remainder != 0:
	bills.append(remainder // denominations[1])
	remainder = remainder % denominations[1]
if remainder != 0:
	bills.append(remainder // denominations[2])
	remainder = remainder % denominations[2]
if remainder != 0:
	bills.append(remainder // denominations[3])
	remainder = remainder % denominations[3]
if remainder != 0:
	bills.append(remainder // denominations[4])
	remainder = remainder % denominations[4]
print(sum(bills))


K = int(input())
C = 0
while K > 0:
	if K // 100 >= 1:
		C += K // 100
		K -= K // 100 * 100
	elif K // 20 >= 1:
		C += K // 20
		K -= K // 20 * 20
	elif K // 10 >= 1:
		C += K // 10
		K -= K // 10 * 10
	elif K // 5 >= 1:
		C += K // 5
		K -= K // 5 * 5
	else:
		C += K
		K = 0
print(C)


n = input()
n = int(n)
x = [100, 20, 10, 5, 1]
gesamt = 0
for i in range(0, len(x)):
	if n < x[i]:
		continue
	else:
		rest = n % x[i]
		x_rest = (n - rest) / x[i]
		gesamt = gesamt + x_rest
		n = rest
print(int(gesamt))


r = lambda : map(int, input().split())
n = int(input())
c = 0
for v in [100, 20, 10, 5, 1]:
	c += int(n / v)
	n %= v
print(int(c))


n = int(input())
s = n // 100
n %= 100
for i in (20, 10, 5, 1):
	while n >= i:
		n -= i
		s += 1
print(s)


def bills(n, c, m):
	if n < 1:
		return 0
	if n < 5:
		return n
	if n < c[m]:
		return bills(n, c, m - 1)
	if n % c[m] == 0:
		return n // c[m]
	return bills(n - n % c[m], c, m) + bills(n % c[m], c, m - 1)
n = int(input())
c = [1, 5, 10, 20, 100]
print(bills(n, c, 4))


amount = int(input())
denominations = [100, 20, 10, 5, 1]
total_bills = 0
while True:
	x_bills = amount // denominations[0]
	amount -= x_bills * denominations[0]
	total_bills += x_bills
	if amount == 0:
		break
	if x_bills == 0:
		del denominations[0]
print(total_bills)


n = int(input())
cout = 0
hun = n % 100
cout += (n - hun) / 100
n = hun
hun = n % 20
cout += (n - hun) / 20
n = hun
hun = n % 10
cout += (n - hun) / 10
n = hun
hun = n % 5
cout += (n - hun) / 5
n = hun
cout += n
print(int(cout))


import math
n = int(input())
uk = 0
if int(n / 100) != 0 and n != 0:
	uk += int(n / 100)
	n = n - 100 * int(n / 100)
if int(n / 20) != 0 and n != 0:
	uk += int(n / 20)
	n = n - 20 * int(n / 20)
if int(n / 10) != 0 and n != 0:
	uk += int(n / 10)
	n = n - 10 * int(n / 10)
if int(n / 5) != 0 and n != 0:
	uk += int(n / 5)
	n = n - 5 * int(n / 5)
if n != 0:
	uk += n
print(uk)


n = int(input())
count = 0
a = int(n / 100)
count = count + a
b = n % 100
c = int(b / 20)
count = count + c
d = b % 20
e = int(d / 10)
count = count + e
f = d % 10
g = int(f / 5)
count = count + g
h = f % 5
count = count + h
print(count)


n = int(input())
a = [100, 20, 10, 5, 1]
ans = 0
cnt = 0
while n != 0:
	for i in a:
		if n >= i:
			cnt = n // i
			n -= cnt * i
			ans += cnt
print(ans)


inp = int(input())
out = 0
if inp / 100 > 0:
	out = int(out + inp / 100)
	inp = inp % 100
if inp / 20 > 0:
	out = int(out + inp / 20)
	inp = inp % 20
if inp / 10 > 0:
	out = int(out + inp / 10)
	inp = inp % 10
if inp / 5 > 0:
	out = int(out + inp / 5)
	inp = inp % 5
if inp / 1 > 0:
	out = int(out + inp / 1)
	inp = inp % 1
print(out)


n = int(input())
hundreds = n // 100
n -= 100 * hundreds
twenties = n // 20
n -= 20 * twenties
tens = n // 10
n -= 10 * tens
fives = n // 5
n -= 5 * fives
print(hundreds + twenties + tens + fives + n)


nn = int(input())
tot = 0
tot += nn // 100
nn = nn % 100
tot += nn // 20
nn = nn % 20
tot += nn // 10
nn = nn % 10
tot += nn // 5
nn = nn % 5
tot += nn
print(tot)


n = int(input())
count = 0
temp = n
l = [100, 20, 10, 5, 1]
ans = 0
for i in l:
	ans += n // i
	n = n % i
print(ans)


def s(n):
	c = [100, 20, 10, 5, 1]
	t = 0
	for i in c:
		if n >= i:
			d = n // i
			t += d
			n -= d * i
	return t
n = int(input())
print(s(n))


n = int(input())
coins = [1, 5, 10, 20, 100]
pos = 4
w = 0
while n > 0:
	if n >= coins[pos]:
		s = n // coins[pos]
		n = n - s * coins[pos]
		w += s
	elif n < coins[pos]:
		pos = pos - 1
print(w)


def ans(m, arr):
	i = 4
	res = 0
	while m > 0:
		temp = m % arr[i]
		res += m // arr[i]
		i -= 1
		m = temp
	return res
m = int(input())
arr = (1, 5, 10, 20, 100)
print(ans(m, arr))


main = int(input())
count = 0
if main != 0:
	q = int(main / 100)
	r = int(main % 100)
	count = count + q
	main = r
if main != 0:
	q = int(main / 20)
	r = int(main % 20)
	count = count + q
	main = r
if main != 0:
	q = int(main / 10)
	r = int(main % 10)
	count = count + q
	main = r
if main != 0:
	q = int(main / 5)
	r = int(main % 5)
	count = count + q
	main = r
if main != 0:
	q = int(main / 1)
	r = int(main % 1)
	count = count + q
	main = r
print(count)


money = int(input())
bills = 0
billSizes = [100, 20, 10, 5, 1]
for x in billSizes:
	leftOver = money % x
	bills += int((money - leftOver) / x)
	money = leftOver
print(bills)


import math
n = int(input())
D = [1, 5, 10, 20, 100]
i = 4
max = 0
while n != 0:
	div = math.floor(n / D[i])
	max += div
	n -= div * D[i]
	i -= 1
print(max)


x = int(input())
a = 0
for i in (100, 20, 10, 5):
	a += x // i
	x %= i
print(a + x)


n = int(input())
t = n // 100
n -= t * 100
c = t
t = n // 20
n -= t * 20
c += t
t = n // 10
n -= t * 10
c += t
t = n // 5
n -= t * 5
c += t
print(c + n)


import sys
n = int(sys.stdin.readline())
a = (100, 20, 10, 5, 1)
b = 0

def add_bills(amount):
	global n, b
	if n / amount >= 1:
		bills = int(n / amount)
		b += bills
		n -= bills * amount
for amount in a:
	add_bills(amount)
print(b)


Saldo = int(input())
CantidadDeBilletes = 0
if Saldo > 99:
	CantidadDeBilletes += Saldo // 100
	Saldo %= 100
if Saldo > 19:
	CantidadDeBilletes += Saldo // 20
	Saldo %= 20
if Saldo > 9:
	CantidadDeBilletes += Saldo // 10
	Saldo %= 10
if Saldo > 4:
	CantidadDeBilletes += Saldo // 5
	Saldo %= 5
if Saldo > 0:
	CantidadDeBilletes += Saldo
	Saldo %= 1
print(CantidadDeBilletes)


CASH_summary = int(input())
CASH_100 = CASH_summary // 100
CASH_20 = CASH_summary % 100 // 20
CASH_10 = CASH_summary % 100 % 20 // 10
CASH_5 = CASH_summary % 100 % 20 % 10 // 5
CASH_1 = CASH_summary % 100 % 20 % 10 % 5
print(CASH_100 + CASH_20 + CASH_10 + CASH_5 + CASH_1)


notes = [100, 20, 10, 5, 1]

def findnum(money):
	total = 0
	while money > 0:
		for note in notes:
			if money >= note:
				total += 1
				money -= note
				break
	return total

def main():
	money = int(input())
	print(findnum(money))
main()


n = []
n.append(1)
n.append(5)
n.append(10)
n.append(20)
n.append(100)
l = int(input())
i = 4
counter = 0
while l > 0:
	if l >= n[i]:
		counter += l // n[i]
		l %= n[i]
	else:
		i -= 1
print(counter)


a = int(input())
bills = 0
while a > 0:
	if a >= 100:
		b = int(a / 100)
		bills += b
		a -= b * 100
		continue
	elif a >= 20:
		a -= 20
	elif a >= 10:
		a -= 10
	elif a >= 5:
		a -= 5
	elif a >= 1:
		a -= 1
	bills += 1
print(bills)


n = int(input())
l = [100, 20, 10, 5, 1]
r = 0
for x in l:
	if n < x:
		continue
	raz = int(n / x)
	r += raz
	n -= raz * x
print(int(r))


count = 0
N = int(input())
if N >= 100 and N % 100 == 0:
	count = N // 100
	print(count)
	exit()
elif N > 100:
	count += N // 100
	N = N % 100
if N >= 20 and N % 20 == 0:
	count += N // 20
	print(count)
	exit()
elif N > 20:
	while N > 20:
		count += 1
		N -= 20
if N >= 10 and N % 10 == 0:
	count += N // 10
	print(count)
	exit()
elif N > 10:
	while N > 10:
		count += 1
		N -= 10
if N >= 5 and N % 5 == 0:
	count += N // 5
	print(count)
	exit()
elif N > 5:
	while N > 5:
		count += 1
		N -= 5
print(count + N)


import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
sys.setrecursionlimit(10000)

def read_int():
	return int(input())

def read_int_n():
	return list(map(int, input().split()))

def read_float():
	return float(input())

def read_float_n():
	return list(map(float, input().split()))

def read_str():
	return input()

def read_str_n():
	return list(map(str, input().split()))

def error_print(*args):
	print(*args, file=sys.stderr)

def mt(f):
	import time

	def wrap(*args, **kwargs):
		s = time.time()
		ret = f(*args, **kwargs)
		e = time.time()
		error_print(e - s, 'sec')
		return ret
	return wrap

@mt
def slv(N):
	ans = 0
	ans += N // 100
	N %= 100
	ans += N // 20
	N %= 20
	ans += N // 10
	N %= 10
	ans += N // 5
	N %= 5
	ans += N // 1
	N %= 1
	return ans

def main():
	N = read_int()
	print(slv(N))
main()


s = int(input())
cont = 0
if s >= 100:
	cont += int(s / 100)
	s = s % 100
if s >= 20:
	cont += int(s / 20)
	s = s % 20
if s >= 10:
	cont += int(s / 10)
	s = s % 10
if s >= 5:
	cont += int(s / 5)
	s = s % 5
if s >= 1:
	cont += s
print(cont)


import sys
billetes = 0
n = int(input())
if n // 100:
	div = n // 100
	billetes = n // 100
	n = n - div * 100
if n // 20:
	div = n // 20
	billetes = billetes + n // 20
	n = n - div * 20
if n // 10:
	div = n // 10
	billetes = billetes + n // 10
	n = n - div * 10
if n // 5:
	div = n // 5
	billetes = billetes + n // 5
	n = n - div * 5
if n // 1:
	div = n // 1
	billetes = billetes + n // 1
	n = n - div * 1
print(billetes)


n = int(input())
bills = [100, 20, 10, 5, 1]
res = 0
i = 0
while n != 0:
	if n < bills[i]:
		i += 1
	else:
		(div, mod) = divmod(n, bills[i])
		res += div
		n = mod
print(res)


n = int(input())
denominations = [1, 5, 10, 20, 100]
output = 0
i = len(denominations) - 1
while n > 0:
	while n >= denominations[i]:
		output += int(n / denominations[i])
		n %= denominations[i]
	i -= 1
print(output)


amt = input()
amt = int(amt)
bills = [20, 10, 5, 1]
count = 0
if amt >= 100:
	a = divmod(amt, 100)
	amt = a[1]
	count = a[0]
for b in bills:
	while b <= amt:
		amt = amt - b
		count = count + 1
print(count)


x = int(input())
res = 0
res += x // 100
x %= 100
res += x // 20
x %= 20
res += x // 10
x %= 10
res += x // 5
x %= 5
res += x
print(res)


n = int(input())
yi = wu = shi = ershi = bai = 0
total = 0
total = total + n // 100
n = n % 100
total = total + n // 20
n = n % 20
total = total + n // 10
n = n % 10
total = total + n // 5
n = n % 5
total = total + n
print(total)


amount = int(input())
bills = [100, 20, 10, 5, 1]
count = 0
while amount != 0:
	if amount >= 100:
		num_of_bills = int(amount / 100)
		amount = amount - num_of_bills * 100
		count += num_of_bills
	elif amount >= 20:
		num_of_bills = int(amount / 20)
		amount = amount - num_of_bills * 20
		count += num_of_bills
	elif amount >= 10:
		num_of_bills = int(amount / 10)
		amount = amount - num_of_bills * 10
		count += num_of_bills
	elif amount >= 5:
		num_of_bills = int(amount / 5)
		amount = amount - num_of_bills * 5
		count += num_of_bills
	else:
		num_of_bills = amount
		amount = amount - num_of_bills
		count += num_of_bills
print(count)


n = int(input())
d = [100, 20, 10, 5, 1]
c = 0
for x in d:
	if n < x:
		continue
	else:
		c += int(n / x)
		n = n % x
print(c)


def func(n):
	arr = [1, 5, 10, 20, 100]
	cnt = 0
	for i in range(len(arr) - 1, -1, -1):
		if n == 0:
			break
		while n >= arr[i]:
			cnt += n // arr[i]
			n -= n // arr[i] * arr[i]
	return cnt
n = int(input())
print(func(n))


n = input()
n = int(n)
count = 0
denoms = [100, 20, 10, 5, 1]
for d in denoms:
	while n >= d:
		a = int(n / d)
		n -= d * a
		count += a
print(count)


def HitInLottery():
	result = 0
	money = int(input())
	if money >= 100:
		result += money // 100
		money -= money // 100 * 100
	if money >= 20:
		result += money // 20
		money -= money // 20 * 20
	if money >= 10:
		result += money // 10
		money -= money // 10 * 10
	if money >= 5:
		result += money // 5
		money -= money // 5 * 5
	if money >= 1:
		result += money
	return result
print(HitInLottery())


a = int(input())
b = 0
b = b + int(a / 100)
a = a % 100
b = b + int(a / 20)
a = a % 20
b = b + int(a / 10)
a = a % 10
b = b + int(a / 5)
a = a % 5
print(b + int(a))


n = int(input())
list1 = [100, 20, 10, 5, 1]
count = 0
while n > 0:
	if list1[0] <= n:
		count += 1
		n -= list1[0]
	elif list1[1] <= n:
		count += 1
		n -= list1[1]
	elif list1[2] <= n:
		count += 1
		n -= list1[2]
	elif list1[3] <= n:
		count += 1
		n -= list1[3]
	elif list1[4] <= n:
		count += 1
		n -= list1[4]
print(count)


def func(n):
	l = [100, 20, 10, 5, 1]
	counter = 0
	while n != 0:
		if n % 100 < n:
			counter += 1
			n -= 100
		elif n % 20 < n:
			counter += 1
			n -= 20
		elif n % 10 < n:
			counter += 1
			n -= 10
		elif n % 5 < n:
			counter += 1
			n -= 5
		elif n % 1 < n:
			counter += 1
			n -= 1
	print(counter)
n = int(input())
func(n)


balance = int(input())
num = balance // 100
balance = balance % 100
num += balance // 20
balance = balance % 20
num += balance // 10
balance = balance % 10
num += balance // 5
num += balance % 5
print(num)


from collections import deque
from collections import OrderedDict
import math
import sys
import os
import threading
import bisect
import operator
import heapq
from atexit import register
from io import BytesIO
import io
input = lambda : sys.stdin.readline().rstrip('\r\n')
arV = [1, 5, 10, 20, 100]
mult = dict()
for i in range(1, len(arV)):
	v = arV[i]
	j = 1
	while v != 1:
		j += 1
		k = 0
		if v % j != 0:
			continue
		while v % j == 0:
			v = v // j
			k += 1
		if k != 0:
			if j in mult:
				mult[j] = max(mult[j], k)
			else:
				mult[j] = k
lastVal = 1
for i in mult:
	lastVal *= i ** mult[i]
n = int(input())
dp = [999999] * (lastVal + 1)
dp[0] = 0
for i in range(len(arV)):
	dp[arV[i]] = 1
for i in range(1, lastVal + 1):
	for j in range(len(arV)):
		if arV[j] > i:
			break
		dp[i] = min(dp[i - arV[j]] + 1, dp[i])
answer = n // lastVal + dp[n % lastVal]
print(answer)


def min_banknots(n):
	banknots = [1, 5, 10, 20, 100]
	total = 0
	i = len(banknots) - 1
	while n > 0:
		if n // banknots[i] >= 0:
			total += n // banknots[i]
			n %= banknots[i]
		i -= 1
	return total
print(min_banknots(int(input())))


def main():
	a = int(input())
	b = 0
	for i in [100, 20, 10, 5, 1]:
		b += a // i
		a %= i
	print(b)
main()


a = int(input())
t = 0
if a >= 100:
	t += a // 100
	a %= 100
if a >= 20:
	t += a // 20
	a %= 20
if a >= 10:
	t += a // 10
	a %= 10
if a >= 5:
	t += a // 5
	a %= 5
if a >= 1:
	t += a // 1
	a %= 5
print(t)


n = int(input())
notas = 0
if n >= 100:
	notas += n // 100
	n = n - notas * 100
if n >= 20:
	notas += n // 20
	n = n - n // 20 * 20
if n >= 10:
	notas += n // 10
	n = n - n // 10 * 10
if n >= 5:
	notas += n // 5
	n = n - n // 5 * 5
if n >= 1:
	notas += n // 1
print(notas)


n = int(input())
money = [1, 5, 10, 20, 100]
counter = 0
for i in reversed(money):
	if n >= i:
		counter += n // i
		n %= i
print(counter)


import sys
input = sys.stdin.readline

def inp():
	return int(input())
n = inp()
k = 0
while n >= 1:
	if n % 100 == 0:
		n -= 100
		k += 1
	elif n % 20 == 0:
		n -= 20
		k += 1
	elif n % 10 == 0:
		n -= 10
		k += 1
	elif n % 5 == 0:
		n -= 5
		k += 1
	else:
		n -= 1
		k += 1
print(k)


money = int(input())
count = 0
while money != 0:
	if money >= 100:
		first_divide = int(money / 100)
		count += first_divide
		money = int(money % 100)
	elif 20 <= money < 100:
		second_divide = int(money / 20)
		count += second_divide
		money = int(money % 20)
	elif 10 <= money < 20:
		third_divide = int(money / 10)
		count += third_divide
		money = int(money % 10)
	elif 5 <= money < 10:
		forth_divide = int(money / 5)
		count += forth_divide
		money = int(money % 5)
	else:
		money -= 1
		count += 1
print(count)


lis = [100, 20, 10, 5, 1]
x = int(input())
n = 0
for i in lis:
	n += x // i
	x = x % i
	if x == 0:
		break
print(n)


a = int(input())
ans = 0
ans += a // 100
a %= 100
ans += a // 20
a %= 20
ans += a // 10
a %= 10
ans += a // 5
a %= 5
ans += a
print(ans)


N = int(input())
doru = [100, 20, 10, 5, 1]
ans = 0
for i in doru:
	(m, d) = divmod(N, i)
	ans += m
	N = d
	if N == 0:
		break
print(ans)


a = int(input())
x = 0
z = 0
y = 0
v = 0
w = 0
if a >= 100:
	x = a // 100
	a = a % 100
if a >= 20:
	y = a // 20
	a = a % 20
if a >= 10:
	z = a // 10
	a = a % 10
if a >= 5:
	v = a // 5
	a = a % 5
if a >= 1:
	w = a // 1
b = x + y + z + w + v
print(b)


money = int(input())
dolbills = 0
while True:
	if money >= 100:
		dolbills = dolbills + int(money // 100)
		money = money % 100
	elif money >= 20:
		dolbills = dolbills + int(money // 20)
		money = money % 20
	elif money >= 10:
		dolbills = dolbills + int(money // 10)
		money = money % 10
	elif money >= 5:
		dolbills = dolbills + int(money // 5)
		money = money % 5
	elif money >= 1:
		dolbills = dolbills + int(money // 1)
		money = money % 1
	else:
		break
print(dolbills)


n = int(input())
a = [100, 20, 10, 5, 1]
ans = 0
for v in a:
	num = n // v
	ans += num
	n -= num * v
print(ans)


n = int(input())
ans = 0
ans = ans + n // 100
r1 = n % 100
ans = ans + r1 // 20
r2 = r1 % 20
ans = ans + r2 // 10
r3 = r2 % 10
ans = ans + r3 // 5
r4 = r3 % 5
ans = ans + r4
print(ans)


def main():
	money = [100, 20, 10, 5, 1]
	sum = int(input())
	c = 0
	for mon in money:
		c += sum // mon
		sum %= mon
	print(c)
main()


t = int(input())
k = t
v = 0
v = t // 100
t = t % 100
v = v + t // 20
t = t % 20
v = v + t // 10
t = t % 10
v = v + t // 5
t = t % 5
v = v + t
print(v)


def cash(n):
	if n >= 100:
		k = n % 100
		if k == 0:
			return int(n / 100)
		else:
			return int(n / 100) + cash(k)
	elif n >= 20:
		k = n % 20
		if k == 0:
			return int(n / 20)
		else:
			return int(n / 20) + cash(k)
	elif n >= 10:
		k = n % 10
		if k == 0:
			return int(n / 10)
		else:
			return int(n / 10) + cash(k)
	elif n >= 5:
		k = n % 5
		if k == 0:
			return int(n / 5)
		else:
			return int(n / 5) + cash(k)
	else:
		return n
n = int(input())
print(cash(n))


n = int(input())
lst = [100, 20, 10, 5, 1]
c = 0
i = 0
while i < 5 and n > 0:
	c += n // lst[i]
	n = n % lst[i]
	i += 1
print(c)


n = int(input())
b = n % 100
n = n - b
i = n / 100
if b < 100:
	while b >= 20:
		b = b - 20
		i = i + 1
if b < 20:
	while b >= 10:
		b = b - 10
		i = i + 1
if b < 10:
	while b >= 5:
		b = b - 5
		i = i + 1
if b < 5:
	while b >= 1:
		b = b - 1
		i = i + 1
print(int(i))


n = int(input())
t = 0
while n / 100 >= 1:
	t += n // 100
	n %= 100
while n / 20 >= 1:
	t += n // 20
	n %= 20
while n / 10 >= 1:
	t += n // 10
	n %= 10
while n / 5 >= 1:
	t += n // 5
	n %= 5
print(int(t + n))


num = int(input())
R = 0
for i in (100, 20, 10, 5):
	R += num // i
	num = num % i
print(num + R)


N = int(input())
S = 0
hundreds = int(N / 100)
S += hundreds
N -= hundreds * 100
twenties = int(N / 20)
S += twenties
N -= twenties * 20
tens = int(N / 10)
S += tens
N -= tens * 10
fives = int(N / 5)
S += fives
N -= fives * 5
S += N
print(S)


m = int(input())
k = int(m / 100)
a = m % 100
k = k + int(a / 20)
b = a % 20
k = k + int(b / 10)
c = b % 10
k = k + int(c / 5) + c % 5
print(k)


n = int(input())
counter = 0
counter += int(n / 100)
n %= 100
counter += int(n / 20)
n %= 20
counter += int(n / 10)
n %= 10
counter += int(n / 5)
n %= 5
counter += n
print(counter)


n = int(input())
hun = n // 100
n = n % 100
twe = n // 20
n = n % 20
ten = n // 10
n = n % 10
fiv = n // 5
n = n % 5
print(hun + twe + fiv + n + ten)


n = int(input().strip())
hund = n // 100
n = n % 100
twen = n // 20
n = n % 20
ten = n // 10
n = n % 10
five = n // 5
n = n % 5
one = n // 1
print(int(hund + twen + ten + five + one))


user_balance = int(input())
denominations = reversed([1, 5, 10, 20, 100])
bills = 0
for denom in denominations:
	current_bills = int(user_balance / denom)
	bills += current_bills
	user_balance -= denom * current_bills
print(bills)


a = int(input())
n = 0
if a >= 100:
	n += a // 100
	a %= 100
if a >= 20:
	n += a // 20
	a %= 20
if a >= 10:
	n += a // 10
	a %= 10
if a >= 5:
	n += a // 5
	a %= 5
if a >= 1:
	n += a
print(n)


n = int(input())
eq = n % 100
cont = n // 100
while eq != 0:
	cont += 1
	if eq >= 20:
		eq -= 20
	elif eq >= 10:
		eq -= 10
	elif eq >= 5:
		eq -= 5
	else:
		eq -= 1
print(cont)


money = int(input())
bills = [100, 20, 10, 5, 1]
i = 0
while money > 0:
	for bill in bills:
		if money >= bill:
			n = money // bill
			money -= bill * n
			i += n
			break
print(i)


from sys import stdin, stdout

def get_number_of_bills(amount):
	available_bills = [100, 20, 10, 5, 1]
	bill_count = 0
	for bill in available_bills:
		while amount >= bill:
			bill_count += 1
			amount -= bill
		if amount == 0:
			break
	stdout.write(f'{bill_count}\n')
amount = int(stdin.readline())
get_number_of_bills(amount)


str = input()
a = int(str)
lst = [100, 20, 10, 5, 1]
cnt = 0
ind = 0
while a > 0:
	while a < lst[ind]:
		ind += 1
	cnt += a // lst[ind]
	a = a % lst[ind]
print(cnt)


p = [100, 20, 10, 5, 1]
t = int(input())
c = 0
c1 = 0
for i in p:
	if t >= i:
		c = int(t / i)
		c1 += c
		t -= i * c
print(c1)


n = int(input())
ans = 0
while n > 0:
	x = n // 100
	if x != 0:
		ans += x
		n = n % 100
	else:
		x2 = n // 20
		if x2 != 0:
			ans += x2
			n = n % 20
		else:
			x3 = n // 10
			if x3 != 0:
				ans += x3
				n = n % 10
			else:
				x4 = n // 5
				if x4 != 0:
					ans += x4
					n = n % 5
				else:
					x5 = n
					if x5 != 0:
						ans += x5
						n = n % 1
print(ans)


def minimum_coins(n):
	coins = [100, 20, 10, 5, 1]
	k = 0
	i = 0
	while n > 0:
		if n < coins[i]:
			i += 1
		else:
			k += n // coins[i]
			n %= coins[i]
	return k
print(minimum_coins(int(input())))


def func(n):
	arr = [1, 5, 10, 20, 100]
	arr.reverse()
	count = 0
	while n != 0:
		for i in arr:
			if n // i >= 1:
				count += n // i
				n %= i
	return count
n = int(input())
print(func(n))


s = 0
n = int(input())
l = [100, 20, 10, 5]
for i in l:
	s += n // i
	n = n % i
s += n
print(s)


n = int(input())
price_of_bill = 0
if n >= 100:
	price_of_bill += n // 100
n = n - 100 * (n // 100)
if n >= 20:
	price_of_bill += n // 20
n = n - 20 * (n // 20)
if n >= 10:
	price_of_bill += n // 10
n = n - 10 * (n // 10)
if n >= 5:
	price_of_bill += n // 5
n = n - 5 * (n // 5)
if n >= 1:
	price_of_bill += n // 1
n = n - 1 * (n // 1)
print(price_of_bill)


a = int(input())
bills = [100, 20, 10, 5, 1]
tot_count = 0
for bill in bills:
	bill_hashtag = int(a / bill)
	a -= bill * bill_hashtag
	tot_count = tot_count + bill_hashtag
	if a == 0:
		break
print(tot_count)


from sys import exit as sys_return
(number, times, it) = (int(input()), 0, 0)
dolla_dolla = [1, 5, 10, 20, 100][::-1]
while number != 0:
	if dolla_dolla[it] <= number:
		times += number // dolla_dolla[it]
		number %= dolla_dolla[it]
	else:
		it += 1
print(times)


q = int(input())
s = 0
while q >= 100:
	s += q // 100
	q = q % 100
while q >= 20:
	s += q // 20
	q = q % 20
while q >= 10:
	s += q // 10
	q = q % 10
while q >= 5:
	s += q // 5
	q = q % 5
if q >= 1:
	s += q
print(s)


received_money = int(input())
count = 0
a = received_money % 100
while True:
	if received_money >= 100:
		count += received_money // 100
		received_money = received_money % 100
	elif received_money >= 20:
		count += received_money // 20
		received_money = received_money % 20
	elif received_money >= 10:
		count += received_money // 10
		received_money = received_money % 10
	elif received_money >= 5:
		count += received_money // 5
		received_money = received_money % 5
	elif received_money >= 1:
		count += received_money // 1
		received_money = received_money % 1
	if received_money == 0:
		break
print(count)


i = int(input())
deno = [1, 5, 10, 20, 100]
bills = 0
for n in range(4, -1, -1):
	cash = deno[n]
	bills += i // cash
	i = i % cash
print(bills)


n = int(input())
b = [100, 20, 10, 5, 1]
m = 0
for i in range(5):
	while n >= b[i]:
		m += n // b[i]
		n %= b[i]
print(m)


x = 0
sum = 0
x = int(input())
sum = int(x / 100)
x = x % 100
sum += int(x / 20)
x = x % 20
sum += int(x / 10)
x = x % 10
sum += int(x / 5)
x = x % 5
sum += int(x / 1)
x = x % 1
print(sum)


N = int(input())
cnt = 0
while N:
	if N >= 100:
		N -= 100
	elif N >= 20:
		N -= 20
	elif N >= 10:
		N -= 10
	elif N >= 5:
		N -= 5
	elif N >= 1:
		N -= 1
	cnt += 1
print(cnt)


def fun(n, i, s):
	if n == 0:
		return n
	return int(n / s[i]) + fun(n % s[i], i - 1, s)
num = int(input())
s = fun(num, 4, (1, 5, 10, 20, 100))
print(s)


n = int(input())
cnt = 0
for v in reversed([1, 5, 10, 20, 100]):
	cnt += n // v
	n %= v
print(cnt)


t = int(input())
c = 0
c += t // 100
a = t % 100
c += a // 20
q = a % 20
c += q // 10
w = q % 10
c += w // 5
c += w % 5
print(c)


total = int(input())
bills = 0
if total % 100 >= 0 and total > 0:
	bills += int(total / 100)
	total = total % 100
if total % 20 >= 0 and total > 0:
	bills += int(total / 20)
	total = total % 20
if total % 10 >= 0 and total > 0:
	bills += int(total / 10)
	total = total % 10
if total % 5 >= 0 and total > 0:
	bills += int(total / 5)
	total = total % 5
if total < 5 and total > 0:
	bills += total
print(bills)


num = int(input())
denom = [100, 20, 10, 5, 1]
i = 0
count = 0
while num != 0:
	if num >= denom[i]:
		count += 1
		num -= denom[i]
	else:
		i += 1
print(count)


def fun1(n, check):
	for i in range(4):
		if check[i] <= n and check[i + 1] > n:
			return check[i]
	return check[-1]

def fun(n):
	check = [1, 5, 10, 20, 100]
	count = 0
	while n > 0:
		x = fun1(n, check)
		c = int(n / x)
		count += c
		n -= x * c
	return count
n = int(input())
print(fun(n))


n = int(input())
m = 0
a = [100, 20, 10, 5, 1]
for elem in a:
	m += n // elem
	n = n % elem
print(m)


a = int(input())
count = 0
ali = 0
if a >= 100:
	count += a // 100
	a = a % 100
if a >= 20:
	count += a // 20
	a = a % 20
if a >= 10:
	count += a // 10
	a = a % 10
if a >= 5:
	count += a // 5
	a = a % 5
if a >= 1:
	count += a // 1
	a = a % 1
print(count)


n = int(input())

def exchange_coins(number):
	if number // 100 >= 1:
		return number // 100 + exchange_coins(number % 100)
	elif number // 20 >= 1:
		return number // 20 + exchange_coins(number % 20)
	elif number // 10 >= 1:
		return number // 10 + exchange_coins(number % 10)
	elif number // 5 >= 1:
		return number // 5 + exchange_coins(number % 5)
	else:
		return number
print(exchange_coins(n))


c = [100, 20, 10, 5, 1]
d = int(input())
count = 0
for i in c:
	count += d // i
	a = d % i
	d = a
print(count)


n = int(input())
a = [100, 20, 10, 5, 1]
i = 0
coin = 0
while n != 0 and i < 5:
	coin += n // a[i]
	n = n % a[i]
	i += 1
print(coin)


n = int(input())
l = [1, 5, 10, 20, 100]
i = len(l) - 1
bills = 0
while n > 0:
	if n >= l[i]:
		bills += n // l[i]
		n = n % l[i]
	if n < l[i]:
		i -= 1
print(bills)


n = int(input(''))
a = int(n / 100)
x = int(n % 100)
b = int(x / 20)
y = int(x % 20)
c = int(y / 10)
z = int(y % 10)
d = int(z / 5)
w = int(z % 5)
print(a + b + c + d + w)


a = int(input())
if a >= 100:
	yuz = int(a / 100)
	yirmi = int(a % (100 * yuz) / 20)
	on = int(a % (100 * yuz + 20 * yirmi) / 10)
	bes = int(a % (100 * yuz + 20 * yirmi + on * 10) / 5)
	bir = int(a % (100 * yuz + 20 * yirmi + on * 10 + bes * 5) / 1)
	print(bir + bes + on + yirmi + yuz)
elif a >= 20:
	yirmi = int(a / 20)
	on = int(a % (20 * yirmi) / 10)
	bes = int(a % (20 * yirmi + on * 10) / 5)
	bir = int(a % (20 * yirmi + on * 10 + bes * 5) / 1)
	print(bir + bes + on + yirmi)
elif a >= 10:
	on = int(a / 10)
	bes = int(a % (on * 10) / 5)
	bir = int(a % (on * 10 + bes * 5) / 1)
	print(bir + bes + on)
elif a >= 5:
	bes = int(a / 5)
	bir = int(a % (bes * 5) / 1)
	print(bir + bes)
elif a >= 1:
	print(a)


l = [1, 5, 10, 20, 100]
l.reverse()
t = int(input())
i = 0
ans = 0
while i < 5:
	if t / l[i] >= 1:
		ans += t // l[i]
		t = t % l[i]
	i += 1
print(ans)


balance = int(input())
denominations = [100, 20, 10, 5, 1]

def minWithdraw(balance):
	numberofbills = 0
	for i in range(len(denominations)):
		numberofbills = numberofbills + int(balance / denominations[i])
		balance = balance % denominations[i]
	return numberofbills
print(minWithdraw(balance))


denominations = [100, 20, 10, 5, 1]
withdraw_balance = int(input())
num_of_bills = 0
for denom in denominations:
	if withdraw_balance <= 0:
		break
	num_of_bills += withdraw_balance // denom
	withdraw_balance %= denom
print(num_of_bills)


numberOfDollars = int(input())
numberOfBills = 0
numberOfBills += numberOfDollars // 100
numberOfDollars = numberOfDollars % 100
numberOfBills += numberOfDollars // 20
numberOfDollars = numberOfDollars % 20
numberOfBills += numberOfDollars // 10
numberOfDollars = numberOfDollars % 10
numberOfBills += numberOfDollars // 5
numberOfDollars = numberOfDollars % 5
numberOfBills += numberOfDollars
print(numberOfBills)


m = [100, 20, 10, 5, 1]
n = int(input())
bills = 0
for i in range(len(m)):
	z = m[i]
	bills += n // z
	n = n % z
print(bills)


t = int(input())
res = 0
while t > 0:
	if t >= 100:
		r = t // 100
		t = t % 100
		res += r
	elif t >= 20:
		r = t // 20
		t = t % 20
		res += r
	elif t >= 10:
		r = t // 10
		t = t % 10
		res += r
	elif t >= 5:
		r = t // 5
		t = t % 5
		res += r
	else:
		r = t
		t = 0
		res += r
print(res)


import math
dollar_denominations = [1, 5, 10, 20, 100]
amount = int(input())
total_dd_used = 0
nodd = 0
for i in reversed(range(len(dollar_denominations))):
	if dollar_denominations[i] > amount:
		continue
	no_of_dd = math.floor(amount / dollar_denominations[i])
	total_dd_used += no_of_dd
	amount = amount - no_of_dd * dollar_denominations[i]
	if amount == 0:
		break
print(total_dd_used)


nums = [100, 20, 10, 5, 1]
n = int(input())
result = 0
i = 0
while n > 0:
	if nums[i] <= n:
		result += n // nums[i]
		n %= nums[i]
	else:
		i += 1
print(result)


x = int(input())
y = [100, 20, 10, 5, 1]
a = 0
for i in y:
	if x // i >= 1:
		a += x // i
		x -= x // i * i
	else:
		pass
print(a)


m = int(input())
bills = sorted([1, 5, 10, 20, 100])
cnt = 0
j = 4
while True:
	if m % 100 == 0:
		print(m // 100)
		exit()
	if m >= bills[j]:
		q = m // bills[j]
		cnt = cnt + q
		m = m - q * bills[j]
	else:
		j = j - 1
	if m == 0:
		break
print(cnt)


cash = [1, 5, 10, 20, 100]
n = int(input())
qtd = 0
for i in range(len(cash) - 1, -1, -1):
	qtd += n // cash[i]
	n %= cash[i]
print(qtd)


n = int(input())
notes = [100, 20, 10, 5, 1]
res = 0
for el in notes:
	res += n // el
	n -= el * (n // el)
print(res)


n = int(input())
t = 0
t += n // 100
u = n % 100
t += u // 20
i = u % 20
t += i // 10
j = i % 10
t += j // 5
w = j % 5
t += w
print(t)


import sys
n = int(sys.stdin.readline())
count = 0
while n != 0:
	for i in [100, 20, 10, 5, 1]:
		p = n / i
		if p >= 1:
			p = int(p)
			n -= p * i
			count += p
print(count)


n = int(input())
ans = 0
if n % 100 == 0:
	ans += n // 100
else:
	ans += n // 100
	n = n % 100
	if n % 20 == 0:
		ans += n // 20
	else:
		ans += n // 20
		n = n % 20
		if n % 10 == 0:
			ans += n // 10
		else:
			ans += n // 10
			n = n % 10
			if n % 5 == 0:
				ans += n // 5
			else:
				ans += n // 5
				n = n % 5
				if n > 0:
					ans += n
print(ans)


def bank(a):
	k = 0
	nomin = [100, 20, 10, 5, 1]
	while a != 0:
		for n in nomin:
			if a - n >= 0:
				a -= n
				break
		k += 1
	return k

def op_bank(a):
	k = 0
	nomin = [100, 20, 10, 5, 1]
	for n in nomin:
		c = a // n
		a -= n * c
		k += c
	return k
a = int(input())
print(op_bank(a))


import sys
bills = [100, 20, 10, 5, 1]
line = sys.stdin.readline()
line.strip()
money = int(line)

def number_of_bills(amount, bills):
	if amount == 0 or bills == []:
		return 0
	quotient = amount // bills[0]
	rest = amount - quotient * bills[0]
	return quotient + number_of_bills(rest, bills[1:])
sys.stdout.write(str(number_of_bills(money, bills)) + '\n')


dollars = [1, 5, 10, 20, 100]
n = 4
inp = int(input())
c = 0
while inp:
	if inp >= dollars[n]:
		c += inp // dollars[n]
		inp = inp % dollars[n]
	else:
		n -= 1
print(c)


n = int(input())
total = 0
lst = [100, 20, 10, 5, 1]
for i in range(5):
	total += n // lst[i]
	n = n % lst[i]
print(total)


N = int(input())
M = [100, 20, 10, 5, 1]
ans = 0
for m in M:
	ans += N // m
	N = N % m
print(ans)


amount = int(input())
d = 0
while amount:
	if amount >= 100:
		amount -= 100
		d += 1
		continue
	elif amount >= 20:
		amount -= 20
		d += 1
		continue
	elif amount >= 10:
		amount -= 10
		d += 1
		continue
	elif amount >= 5:
		amount -= 5
		d += 1
		continue
	else:
		amount -= 1
		d += 1
		continue
print(d)


money = int(input())
c1 = money // 100
Remainingamount = money % 100
c2 = Remainingamount // 20
Remainingamount = Remainingamount % 20
c3 = Remainingamount // 10
Remainingamount %= 10
c4 = Remainingamount // 5
Remainingamount %= 5
c5 = Remainingamount
total = c1 + c2 + c3 + c4 + c5
print(total)


n = int(input())
cnt = 0
while n:
	if n / 100 >= 1:
		m = n // 100
		n = n - m * 100
		cnt += m
	elif n / 20 >= 1:
		m = n // 20
		n = n - m * 20
		cnt += m
	elif n / 10 >= 1:
		m = n // 10
		n = n - m * 10
		cnt += m
	elif n / 5 >= 1:
		m = n // 5
		n = n - m * 5
		cnt += m
	elif n / 1 >= 1:
		m = n // 1
		n = n - m * 1
		cnt += m
print(cnt)


n = int(input())
S = n // 100
n %= 100
S += n // 20
n %= 20
S += n // 10
n %= 10
S += n // 5
n %= 5
S += n
print(S)


def findMin(V):
	deno = [1, 5, 10, 20, 100]
	n = len(deno)
	ans = []
	i = n - 1
	while i >= 0:
		while V >= deno[i]:
			V -= deno[i]
			ans.append(deno[i])
		i -= 1
	print(len(ans))
n = int(input())
findMin(n)


b = [1, 5, 10, 20, 100]
n = int(input())
i = 4
ans = 0
while n:
	ans += n // b[i]
	n %= b[i]
	i -= 1
print(ans)


t = int(input())
x = 0
if t >= 100:
	x += int(t / 100)
	t = t % 100
if t >= 20:
	x += int(t / 20)
	t = t % 20
if t >= 10:
	x += int(t / 10)
	t = t % 10
if t >= 5:
	x += int(t / 5)
	t = t % 5
print(x + t)


n = int(input())
c = 0
d = [100, 20, 10, 5, 1]
while n:
	while d[0] > n:
		d = d[1:]
	c += n // d[0]
	n %= d[0]
print(c)


amount = int(input())
count = 0
if amount % 100 > 0:
	count += amount // 100
	amount = amount % 100
elif amount % 100 == 0 and amount >= 100:
	count += amount // 100
	amount = 0
if amount % 20 > 0:
	count += amount // 20
	amount = amount % 20
elif amount % 20 == 0 and amount >= 20:
	count += amount // 20
	amount = 0
if amount % 10 >= 0:
	count += amount // 10
	amount = amount % 10
elif amount % 10 == 0 and amount >= 10:
	count += amount // 10
	amount = 0
if amount % 5 >= 0:
	count += amount // 5
	amount = amount % 5
elif amount % 5 == 0 and amount >= 5:
	count += amount // 5
	amount = 0
if amount % 1 >= 0:
	count += amount // 1
	amount = amount % 1
elif amount % 1 == 0 and amount >= 1:
	count += amount // 1
	amount = 0
print(count)


import math
from sys import stdin

def get_number_of_bills(amount):
	bills = 0
	if amount / 100 >= 1:
		bills += math.floor(amount / 100)
		amount = amount % 100
	if amount / 20 >= 1:
		bills += math.floor(amount / 20)
		amount = amount % 20
	if amount / 10 >= 1:
		bills += math.floor(amount / 10)
		amount = amount % 10
	if amount / 5 >= 1:
		bills += math.floor(amount / 5)
		amount = amount % 5
	if amount:
		bills += amount
	print(bills)
amount = int(stdin.readline())
get_number_of_bills(amount)


import sys
import math
mod = 998244353
cases = False
dynamic_factorial = False

def main(test_case=False):
	n = int(input()) if test_case else 1
	for _ in range(n):
		test()

def fast_pow(a: int, b: int):
	res = 1
	while b > 0:
		if b & 1:
			res *= a
		a *= a
		b >>= 1
	return res

def c2(n):
	return n * (n - 1) // 2

def get():
	return list(map(int, input().split()))

def bits(n: int):
	return list(bin(n)).count('1')

def flush():
	sys.stdout.flush()

def parr(arr):
	print(*arr, sep=' ')

def gcd(a, b):
	while b:
		if b % a == 0:
			break
		tmp = a
		a = b % a
		b = tmp
	return a

def ext_gcd(a: int, b: int):
	if b == 0:
		return [a, [1, 0]]
	res = ext_gcd(b, a % b)
	g = res[0]
	if g != 1:
		return False
	x1 = res[1][0]
	y1 = res[1][1]
	x = y1
	y = x1 - y1 * (a // b)
	return [g, [x, y]]

def get_set(a):
	res = {}
	for x in a:
		if x in res:
			res[x] += 1
		else:
			res[x] = 1
	return res
fact = {0: 1}

def factorial(n):
	if dynamic_factorial:
		if n not in fact:
			fact[n] = factorial(n - 1) * n
		return fact[n]
	else:
		res = 1
		while n > 0:
			res = res * n % mod
			n -= 1
		return res

def sum_of(a):
	res = 0
	for x in a:
		res = (res + x) % mod
	return res

def prod_of(a):
	res = 1
	for x in a:
		res = res * x % mod
	return res

def test():
	n = get()[0]
	ans = 0
	ans += n // 100
	n %= 100
	ans += n // 20
	n %= 20
	ans += n // 10
	n %= 10
	ans += n // 5
	n %= 5
	ans += n
	print(ans)
main(cases)


n = int(input())
cnt = 0
rem = n
hundreds = rem // 100
cnt += hundreds
rem -= hundreds * 100
twenty = rem // 20
cnt += twenty
rem -= twenty * 20
dec = rem // 10
cnt += dec
rem -= dec * 10
five = rem // 5
cnt += five
rem -= five * 5
one = rem // 1
cnt += one
print(cnt)


n = int(input())
cntr = n // 100
n %= 100
cntr += n // 20
n %= 20
cntr += n // 10
n %= 10
cntr += n // 5
n %= 5
print(cntr + n)


n = int(input())
count = 0
amount_left = n
x = 0
if n >= 100:
	if n / 100 == 0:
		count = int(n / 100)
	else:
		count = int(n / 100)
		n = n % 100
if n >= 20:
	if n / 20 == 0:
		x = int(n / 20)
		count = count + x
	else:
		x = int(n / 20)
		count += x
		n = n % 20
if n >= 10:
	if n / 10 == 0:
		x = int(n / 10)
		count += x
	else:
		x = int(n / 10)
		count += x
		n = n % 10
if n >= 5:
	if n / 5 == 0:
		x = int(n / 5)
		count += x
	else:
		x = int(n / 5)
		count += x
		n = n % 5
if n >= 1:
	x = int(n / 1)
	count += x
print(count)


t = int(input())
res = 0
res += t // 100
t = t % 100
res += t // 20
t = t % 20
res += t // 10
t = t % 10
res += t // 5
t = t % 5
res += t
print(res)


x = int(input())
n = int()
while x > 0:
	if x % 1000 == 0:
		n = n + 10
		if x >= 100:
			x = x - 1000
	else:
		n = n + 1
		if x % 100 == 0:
			x = x - 100
		elif x % 20 == 0:
			x = x - 20
		elif x % 10 == 0:
			x = x - 10
		elif x % 5 == 0:
			x = x - 5
		else:
			x = x - 1
print(n)


n = int(input())
times = 0
again = True
while n != 0:
	if n >= 100:
		n -= 100
		times += 1
	elif n >= 20:
		n -= 20
		times += 1
	elif n >= 10:
		n -= 10
		times += 1
	elif n >= 5:
		n -= 5
		times += 1
	else:
		n -= 1
		times += 1
print(times)


n = int(input())
if n > 0 and n < 10 ** 9 + 1:
	x = 0
	x = n // 100
	n = n % 100
	x = x + n // 20
	n = n % 20
	x = x + n // 10
	n = n % 10
	x = x + n // 5
	n = n % 5
	x = x + n // 1
	print(x)


def iinput():
	return [int(i) for i in input().split()]
n = int(input())
ans = 0
ans += n // 100
n = n % 100
ans += n // 20
n = n % 20
ans += n // 10
n = n % 10
ans += n // 5
n = n % 5
ans += n
print(ans)


def hit(n):
	cont = 0
	while n > 0:
		if n >= 100:
			cont += n // 100
			n = n % 100
		elif n >= 20:
			cont += n // 20
			n = n % 20
		elif n >= 10:
			cont += n // 10
			n = n % 10
		elif n >= 5:
			cont += n // 5
			n = n % 5
		elif n >= 1:
			cont += n // 1
			n = n % 1
	return cont
print(hit(int(input())))


l = [1, 5, 10, 20, 100]
i = 4
n = int(input())
m = n
(s, nb) = (0, 0)
while s < n:
	if m // l[i] == 0:
		i -= 1
	s += m // l[i] * l[i]
	nb += m // l[i]
	m -= m // l[i] * l[i]
print(nb)


_list_ = [100, 20, 10, 5, 1]
(money, value) = (int(input()), 0)
for d in _list_:
	value += money // d
	money %= d
print(value)


a = int(input())
b = a // 100
a = a % 100
c = a // 20
a = a % 20
d = a // 10
a = a % 10
e = a // 5
a = a % 5
print(a + b + c + d + e)


n = int(input())
r = n % 100
b = int(n / 100)
while r != 0:
	b += 1
	if r >= 20:
		r = r - 20
	elif r >= 10:
		r = r - 10
	elif r >= 5:
		r = r - 5
	else:
		r = r - 1
print(b)


n = int(input())
min_bills = 0
min_bills += n // 100
n = n % 100
min_bills += n // 20
n = n % 20
min_bills += n // 10
n = n % 10
min_bills += n // 5
n = n % 5
min_bills += n
n = 0
print(min_bills)


def withdraw(number):
	bills = [1, 5, 10, 20, 100]
	bills = [100, 20, 10, 5, 1]
	total_bills = 0
	for bill in bills:
		quotient = number // bill
		total_bills += int(quotient)
		if not quotient:
			pass
		else:
			number -= bill * quotient
	print(total_bills)
inp = input()
number = inp
withdraw(int(number))


n = int(input())
coins = [100, 20, 10, 5, 1]
num_of_notes = 0
for coin in coins:
	num_of_notes += n // coin
	n %= coin
print(num_of_notes)


import math

def money(n):
	bils = [100, 20, 10, 5, 1]
	if n == 0:
		return 0
	else:
		for i in bils:
			if i <= n:
				return money(n % i) + n // i
x = int(input())
print(money(x))


conto = input()
conto = int(conto)
lista = [100, 20, 10, 5, 1]
continua = True
bills = 0
while conto > 100:
	k = str(conto)
	k = len(k) - 1
	y = '1' + '0' * k
	y = int(y)
	conto -= y
	bills += y / 100
if conto != 0:
	while continua:
		for x in lista:
			a = conto - x
			if a == 0:
				bills += 1
				continua = False
				break
			if a < 0:
				continue
			elif a > 0:
				bills += 1
				conto = conto - x
				break
print(int(bills))


bills = [100, 20, 10, 5, 1]
n = int(input())
count = 0
for pis in bills:
	if n <= 0:
		break
	c = n // pis
	count += c
	n -= c * pis
print(count)


n = int(input())
arr = [100, 20, 10, 5, 1]
cnt = 0
for j in range(5):
	cnt += n // arr[j]
	n %= arr[j]
print(cnt)


n = int(input())
c = 0
if n / 100 >= 1:
	d = n / 100
	d = int(d)
	for i in range(d):
		n = n - 100
		c += 1
if n / 20 >= 1:
	d = n / 20
	d = int(d)
	for i in range(d):
		n = n - 20
		c += 1
if n / 10 >= 1:
	d = n / 10
	d = int(d)
	for i in range(d):
		n = n - 10
		c += 1
if n / 5 >= 1:
	d = n / 5
	d = int(d)
	for i in range(d):
		n = n - 5
		c += 1
if n / 1 >= 1:
	d = n / 1
	d = int(d)
	for i in range(d):
		n = n - 1
		c += 1
print(c)


n = int(input())
a = [100, 20, 10, 5, 1]
j = 0
while n != 0:
	b = [bool(n >= i) for i in a]
	for i in range(5):
		if b[i] == True:
			j += n // a[i]
			n -= int(n / a[i]) * a[i]
			break
print(j)


n = int(input())
notes = [100, 20, 10, 5, 1]
bills = 0
for i in range(len(notes)):
	bills += n // notes[i]
	n = n % notes[i]
print(bills)


import sys
n = int(sys.stdin.readline())
count = 0
for b in (100, 20, 10, 5, 1):
	if n >= b:
		count += n // b
		n %= b
print(count)


n = int(input())
num_notes = 0
for d in sorted([100, 20, 10, 5, 1], reverse=True):
	if n >= d:
		m = n // d
		n -= m * d
		num_notes += m
print(num_notes)


get = int(input())
nobills = 0
if 1 <= get <= 10 ** 9:
	while get >= 1:
		if get >= 100:
			get -= 100
		elif get >= 20:
			get -= 20
		elif get >= 10:
			get -= 10
		elif get >= 5:
			get -= 5
		elif get >= 1:
			get -= 1
		nobills += 1
print(nobills)


n = int(input())
c = 0
while n != 0:
	if n >= 100:
		q = n // 100
		c += q
		r = n % 100
		n = r
	elif n >= 20 and n < 100:
		q = n // 20
		c += q
		r = n % 20
		n = r
	elif n >= 10 and n < 20:
		q = n // 10
		c += q
		r = n % 10
		n = r
	elif n >= 5 and n < 10:
		q = n // 5
		c += q
		r = n % 5
		n = r
	elif n >= 1 and n < 5:
		q = n // 1
		c += q
		r = n % 1
		n = r
print(c)


n = int(input())
arr = [100, 20, 10, 5, 1]
ans = 0
for v in arr:
	ans += n // v
	n %= v
print(ans)


n = int(input())
kyp = n // 100
n = n % 100
kyp += n // 20
n = n % 20
kyp += n // 10
n = n % 10
kyp += n // 5
n = n % 5
kyp += n
print(kyp)


n = int(input())
a = [100, 20, 10, 5, 1]
counter = 0
while n != 0:
	if n // a[0] > 0:
		c = n // a[0]
		counter += c
		n -= c * a[0]
	elif n // a[1] > 0:
		c = n // a[1]
		counter += c
		n -= c * a[1]
	elif n // a[2] > 0:
		c = n // a[2]
		counter += c
		n -= c * a[2]
	elif n // a[3] > 0:
		c = n // a[3]
		counter += c
		n -= c * a[3]
	elif n // a[4] > 0:
		c = n // a[4]
		counter += c
		n -= c * a[4]
print(counter)


z = [1, 5, 10, 20, 100]
z.reverse()
global rem
num = 0
q = int(input())
for p in range(5):
	if q / z[p] >= 1:
		num += int(q / z[p])
		rem = int(q % z[p])
		if rem == 0:
			print(num)
			break
		elif rem > 0:
			q = rem


n = int(input(''))
t = 0
while n >= 100:
	if n == 10 ^ 9:
		n = n - (10 ^ 2)
		t = t + 1
		if n == 0:
			break
	else:
		n = n - 100
		t = t + 1
for i in range(0, n, 1):
	if n >= 20 and n < 100:
		n = n - 20
		t = t + 1
	if n >= 10 and n < 20:
		n = n - 10
		t = t + 1
	if n >= 5 and n < 10:
		n = n - 5
		t = t + 1
	if n >= 1 and n < 5:
		n = n - 1
		t = t + 1
print(t)


import sys
input = sys.stdin.readline
n = int(input())
ans = 0
a = [100, 20, 10, 5, 1]
for x in a:
	ans += n // x
	n %= x
print(ans)


sum = int(input())
n100 = sum // 100
sum -= n100 * 100
n20 = sum // 20
sum -= n20 * 20
n10 = sum // 10
sum -= n10 * 10
n5 = sum // 5
sum -= n5 * 5
print(n100 + n20 + n10 + n5 + sum)


import math
bills = [100, 20, 10, 5, 1]
n = int(input())
s = 0
for b in bills:
	s += n // b
	n %= b
print(s)


from typing import List

def solve(n: int) -> str:
	ret = 0
	for bill in [100, 20, 10, 5, 1]:
		if n >= bill:
			cnt = n // bill
			ret += cnt
			n -= bill * cnt
	assert n == 0
	return ret

def compare(user_answer: int, jury_answer: int) -> bool:
	return user_answer == jury_answer
print(solve(*map(int, input().split())))


n = int(input())
kup_100 = n // 100
kup_20 = n % 100 // 20
kup_10 = n % 100 % 20 // 10
kup_5 = n % 100 % 20 % 10 // 5
kup_1 = n % 100 % 20 % 10 % 5 // 1
sum = kup_100 + kup_20 + kup_10 + kup_5 + kup_1
print(sum)


n = int(input())
x = n // 100
n %= 100
for r in [20, 10, 5, 1]:
	while n and n >= r:
		x += 1
		n -= r
print(x)


n = int(input())
b = 0
b += n // 100
n -= n // 100 * 100
b += n // 20
n -= n // 20 * 20
b += n // 10
n -= n // 10 * 10
b += n // 5
n -= n // 5 * 5
print(b + n)


a = int(input())
b1 = a // 100
b2 = a % 100
c1 = b2 // 20
c2 = b2 % 20
d1 = c2 // 10
d2 = c2 % 10
e1 = d2 // 5
e2 = d2 % 5
f = b1 + c1 + d1 + e1 + e2
print(f)


n = int(input())
su = 0
a0 = int(n / 100)
su += a0
n -= int(100 * a0)
a2 = int(n / 20)
su += a2
n -= int(20 * a2)
a3 = int(n / 10)
su += a3
n -= int(10 * a3)
a4 = int(n / 5)
su += a4
n -= int(5 * a4)
print(su + n)


money = int(input())
currency = [1, 5, 10, 20, 100]
notes = 0
for val in currency[::-1]:
	notes += money // val
	money = money % val
print(notes)


a = int(input())
coins = [100, 20, 10, 5, 1]
rez = 0
for c in coins:
	rez += a // c
	a = a % c
print(rez)


import sys
from random import choice, randint
inp = sys.stdin.readline
out = sys.stdout.write
flsh = sys.stdout.flush
sys.setrecursionlimit(10 ** 9)
inf = 10 ** 20
eps = 1.0 / 10 ** 10
mod = 10 ** 9 + 7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]

def MI():
	return map(int, inp().strip().split())

def LI():
	return list(map(int, inp().strip().split()))

def LLI():
	return [list(map(int, l.split())) for l in sys.stdin.readlines().strip()]

def LI_():
	return [int(x) - 1 for x in inp().strip().split()]

def LF():
	return [float(x) for x in inp().strip().split()]

def LS():
	return inp().strip().split()

def I():
	return int(inp().strip())

def F():
	return float(inp().strip())

def S():
	return inp().strip()

def pf(s):
	return out(s + '\n')

def JA(a, sep):
	return sep.join(map(str, a))

def JAA(a, s, t):
	return s.join((t.join(map(str, b)) for b in a))

def main():
	n = I()
	l = [100, 20, 10, 5, 1]
	c = 0
	i = 0
	while n > 0:
		c += n // l[i]
		n = n % l[i]
		i += 1
	pf(str(c))
main()


n = int(input())
c = n // 100
left = n % 100
c = c + left // 20
left = left % 20
c = c + left // 10
left = left % 10
c = c + left // 5
left = left % 5
c = c + left
print(c)


from sys import stdin, stdout
from sys import maxsize

def solve(n):
	ans = 0
	ans += n // 100
	n = n % 100
	ans += n // 20
	n = n % 20
	ans += n // 10
	n = n % 10
	ans += n // 5
	n = n % 5
	ans += n
	print(ans)
	pass
test = 1
for t in range(0, test):
	n = int(input())
	ans = solve(n)


n = int(input())
ans = 0
while n > 0:
	ans += 1
	if n - 100 >= 0:
		n -= 100
	elif n - 20 >= 0:
		n -= 20
	elif n - 10 >= 0:
		n -= 10
	elif n - 5 >= 0:
		n -= 5
	elif n - 1 >= 0:
		n -= 1
print(ans, flush=True)


a = int(input())
l = [100, 20, 10, 5, 1]
c = 0
for i in l:
	x = int(a / i)
	if x != 0:
		a = a - x * i
	c += x
print(c)


n = int(input())
s = n // 100
p = n % 100
t = p // 20
h = p % 20
k = h // 10
l = h % 10
m = l // 5
n = l % 5
u = n // 1
print(s + t + k + m + u)


n = int(input())
result = n // 100
r = n % 100
result += r // 20
k = r % 20
result += k // 10
r = k % 10
result += r // 5
k = r % 5
result += k // 1
print(result)


denominations = [100, 20, 10, 5, 1]
amount = int(input())
count = 0
for denom in denominations:
	count += amount // denom
	amount %= denom
print(count)


x = int(input(''))
m = 0
if x == 0:
	print
if x >= 100:
	m += int(x / 100)
	if x / 100 != int(x / 100):
		x = round((x / 100 - int(x / 100)) * 100)
if x < 100 and x >= 20:
	m += int(x / 20)
	if x / 20 != int(x / 20):
		x = round((x / 20 - int(x / 20)) * 20)
if x < 20 and x >= 10:
	m += int(x / 10)
	if x / 10 != int(x / 10):
		x = round((x / 10 - int(x / 10)) * 10)
if x < 10 and x >= 5:
	m += 1
	x = x - 5
if x < 5:
	m += x
print(m)


n = int(input())
m100 = n // 100
m20 = n % 100 // 20
m10 = n % 100 % 20 // 10
m5 = n % 100 % 20 % 10 // 5
m1 = n % 100 % 20 % 10 % 5 // 1
m = m100 + m20 + m10 + m5 + m1
print(m)


cash = int(input())
units = [100, 20, 10, 5, 1]
bills = 0
for unit in units:
	if cash < 5:
		bills += cash
		break
	if cash < unit:
		continue
	bills += cash // unit
	cash %= unit
print(bills)


total = int(input())
num1 = total % 5
num100 = total // 100
rest1 = total % 100
num20 = rest1 // 20
rest2 = rest1 % 20
answer = 0
if rest2 < 5:
	answer = num1 + num100 + num20
elif rest2 >= 5 and rest2 < 15:
	answer = num1 + num100 + num20 + 1
else:
	answer = num1 + num100 + num20 + 2
print(answer)


n = int(input())
nums = (100, 20, 10, 5, 1)
j = 0
total = 0
while n > 0:
	total = total + n // nums[j]
	k = n // nums[j]
	n = n - k * nums[j]
	j = j + 1
print(total)


money = int(input(''))
loop = True
counter = 0
list = [100, 20, 10, 5, 1]
for i in list:
	while money - i >= 0:
		value = int(len(str(money)))
		if i == 100:
			value = 10 ** (value - 3)
		elif i == 20:
			value = 10 ** (value - 2)
		elif i == 10:
			value = 10 ** (value - 2)
		money -= i * value
		counter += value
print(int(counter))


a = int(input())
ans = 0
ca = a
if a >= 100 and a > 0:
	k = a // 100
	ca = a - k * 100
	ans += k
if ca >= 20 and ca > 0:
	k = ca // 20
	ca = ca - k * 20
	ans += k
if ca >= 10 and ca > 0:
	k = ca // 10
	ca -= k * 10
	ans += k
if ca >= 5 and ca > 0:
	k = ca // 5
	ca = ca - k * 5
	ans += k
if ca >= 1 and ca > 0:
	ans += ca
print(ans)


x = int(input())
hundreds = x // 100
twentys = (x - 100 * hundreds) // 20
tens = (x - 100 * hundreds - twentys * 20) // 10
fives = (x - 100 * hundreds - twentys * 20 - tens * 10) // 5
ones = x - 100 * hundreds - twentys * 20 - tens * 10 - fives * 5
print(hundreds + twentys + fives + ones + tens)


n = int(input())
bill = [100, 20, 10, 5, 1]
bills = 0
while n != 0:
	if n // bill[0] > 0:
		bills = bills + n // bill[0]
		n = n % bill[0]
		bill.remove(bill[0])
	else:
		bill.remove(bill[0])
print(bills)


ban = [1, 5, 10, 20, 100]
n = int(input())
how_many = 0
last = len(ban) - 1
while last >= 1:
	if n // ban[last] > 0:
		how_many_tmp = n // ban[last]
		how_many += how_many_tmp
		n -= how_many_tmp * ban[last]
	last -= 1
how_many += n
print(how_many)


n = int(input())
l = [100, 20, 10, 5, 1]
c = 0
i = 0
while n > 4:
	if n >= l[i]:
		c += n // l[i]
		n = n % l[i]
	i += 1
c += n
print(c)


import math, sys, os
from collections import defaultdict, deque, OrderedDict, Counter
import bisect as bi
from io import BytesIO, IOBase
mod = 10 ** 9 + 7
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):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		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))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')

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

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

def inp():
	return int(input())

def print_list(l):
	print(' '.join(map(str, l)))

def BinarySearch(a, x):
	i = bi.bisect_left(a, x)
	if i != len(a) and a[i] == x:
		return i
	else:
		return -1

def gcd(a, b):
	return math.gcd(a, b)

def is_prime(n):
	if n < 5 or n & 1 == 0 or n % 3 == 0:
		return 2 <= n <= 3
	s = (n - 1 & 1 - n).bit_length() - 1
	d = n >> s
	for a in [2, 325, 9375, 28178, 450775, 9780504, 1795265022]:
		p = pow(a, d, n)
		if p == 1 or p == n - 1 or a % n == 0:
			continue
		for _ in range(s):
			p = p * p % n
			if p == n - 1:
				break
		else:
			return False
	return True

def mulinverse(a):
	return pow(a, mod - 2, mod)
n = inp()
a = [100, 20, 10, 5, 1]
ans = 0
for c in a:
	if n >= c:
		ans += n // c
		n = n % c
print(ans)


t = int(input())
hcount = 0
tcount = 0
ten = 0
five = 0
one = 0
hcount += t // 100
t = t % 100
tcount += t // 20
t = t % 20
ten += t // 10
t = t % 10
five += t // 5
t = t % 5
one += t // 1
t = t % 1
print(hcount + tcount + ten + five + one)


import sys
n = int(input())
res = 0
for i in [100, 20, 10, 5, 1]:
	res += n // i
	n %= i
print(res)


coins = [100, 20, 10, 5, 1]

def main():
	n = int(input())
	total = 0
	for coin in coins:
		total += n // coin
		n = n % coin
	print(total)
main()


n = int(input())
notes = []
for i in range(1):
	if n >= 100:
		notes.append(n // 100)
		if n % 100 == 0:
			break
		else:
			n %= 100
	if n >= 20:
		notes.append(n // 20)
		if n % 20 == 0:
			break
		else:
			n %= 20
	if n >= 10:
		notes.append(n // 10)
		if n % 10 == 0:
			break
		else:
			n %= 10
	if n >= 5:
		notes.append(n // 5)
		if n % 5 == 0:
			break
		else:
			n %= 5
	if n > 0:
		notes.append(n)
su = 0
for i in notes:
	su += i
print(su)


bills = [100, 20, 10, 5, 1]
dollars = int(input())
bills_to_receive = 0
for bill in bills:
	if dollars >= bill:
		bills_to_receive += dollars // bill
		dollars -= dollars // bill * bill
print(bills_to_receive)


total = int(input())
add = 0
ans = 0
list = [100, 20, 10, 5, 1]
for i in list:
	while add + i <= total:
		if (total - add) % i == 0:
			ans += int((total - add) / i)
			add = total
		else:
			temp = int((total - add) / i)
			add += i * temp
			ans += temp
print(ans)


import math
n = 0

def read_input():
	global n
	n = int(input())

def solve():
	denoms = [100, 20, 10, 5, 1]
	count = 0
	m = n
	while True:
		for denom in denoms:
			if m - denom >= 0:
				count = count + 1
				m = m - denom
				break
		if m <= 0:
			break
	return count
read_input()
print(solve())


amount = int(input())
result = 0
bills = [100, 20, 10, 5, 1]
for bill in bills:
	result += int(amount / bill)
	amount = amount % bill
print(result)


list = [1, 5, 10, 20, 100]
inp = int(input())
x = 0
y = True
counter_1 = 0
counter_2 = 1
while y:
	if inp >= 100:
		x += inp // 100
		if inp % 100 == 0:
			y = False
		else:
			inp = inp % 100
			continue
	elif inp in list:
		x += 1
		y = False
	elif inp < list[counter_2] and inp > list[counter_1]:
		x += inp // list[counter_1]
		inp = inp % list[counter_1]
		if inp == 0:
			y = False
		counter_1 = -1
		counter_2 = 0
	counter_1 += 1
	counter_2 += 1
print(x)


import math
money = input()
money = int(money)
count = 0
res = 0
res = math.floor(money / 100)
if res > 0:
	count += res
	money = money - res * 100
if money > 0:
	res = math.floor(money / 20)
	if res > 0:
		count += res
		money = money - 20 * res
if money > 0:
	res = math.floor(money / 10)
	if res > 0:
		count += res
		money = money - 10 * res
if money > 0:
	res = math.floor(money / 5)
	if res > 0:
		count += res
		money = money - 5 * res
if money > 0:
	res = math.floor(money / 1)
	if res > 0:
		count += res
print(math.floor(count))


n = int(input())
s = 0
l = [100, 20, 10, 5, 1]
for i in range(5):
	r = int(n / l[i])
	s += r
	p = n % l[i]
	if p == 0:
		print(s)
		break
	else:
		n = p


import math
n = int(input())
coin_digits = [100, 20, 10, 5, 1]
coin_amount = 0
for digit in coin_digits:
	if n / digit >= 1:
		coin_amount += math.floor(n / digit)
		n = n - math.floor(n / digit) * digit
	else:
		pass
print(coin_amount)


n = int(input())
s = 0
l = [100, 20, 10, 5, 1]
for i in l:
	s += n // i
	n %= i
	if n == 0:
		break
print(s)


n = int(input())
x = [100, 20, 10, 5, 1]
cont = 0
indice = 0
div = x[indice]
rest = n
while rest != 0:
	cont += int(rest / div)
	rest = rest % div
	if rest != 0:
		indice += 1
		div = x[indice]
print(cont)


denoms = [100, 20, 10, 5, 1]
N = int(input())
count = 0
for d in denoms:
	count = count + int(N / d)
	N = N % d
print(count)


def main():
	N = int(input())
	c = 0
	h = N // 100
	c += h
	N -= h * 100
	h = N // 20
	c += h
	N -= h * 20
	h = N // 10
	c += h
	N -= h * 10
	h = N // 5
	c += h
	N -= h * 5
	c += N
	print(c)
main()


notes = [100, 20, 10, 5, 1]
res = 0
n = int(input())
for note in notes:
	if n < note:
		continue
	res += n // note
	n = n % note
print(res)


s = input()
l = len(s)
i = l
n = 0
if i > 2:
	t = s[0:l - 2]
	n = n + int(t)
	i = i - (l - 2)
t = int(s[l - 2:l])
n = n + int(t / 20) + int(t % 20 / 10) + int(t % 10 / 5) + int(t % 5 / 1)
print(int(n))


l = [100, 20, 10, 5, 1]
(x, s) = (int(input()), 0)
for i in l:
	s += x // i
	x %= i
print(s)


def lottery(n):
	result = 0
	for bills in [100, 20, 10, 5, 1]:
		nbills = n // bills
		result += nbills
		n -= bills * nbills
	return result
n = int(input())
print(lottery(n))


num = int(input())
res = 0
while num > 0:
	if num >= 100:
		res += num // 100
		num = num % 100
	elif num >= 20:
		res += num // 20
		num = num % 20
	elif num >= 10:
		res += num // 10
		num = num % 10
	elif num >= 5:
		res += num // 5
		num = num % 5
	else:
		res += 1
		num -= 1
print(res)


money = int(input())
hundreds = money // 100
money -= hundreds * 100
twentys = money // 20
money -= twentys * 20
tens = money // 10
money -= tens * 10
fives = money // 5
money -= fives * 5
ones = money
money -= ones * 1
s = hundreds + twentys + tens + fives + ones
print(str(s))


n = int(input())
utils = [100, 20, 10, 5, 1]
aux = n
i = 0
ops = 0
while i < len(utils):
	tmp = aux
	aux -= utils[i]
	if aux >= 0:
		ops += 1
		continue
	else:
		i += 1
		aux = tmp
print(ops)


from sys import stdin, stdout
import math, sys, heapq
from itertools import permutations, combinations
from collections import defaultdict, deque, OrderedDict
from os import path
import random
import bisect as bi

def yes():
	print('YES')

def no():
	print('NO')
if path.exists('input.txt'):
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')

	def I():
		return int(input())

	def In():
		return map(int, input().split())
else:

	def I():
		return int(stdin.readline())

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

def dict(a):
	d = {}
	for x in a:
		if d.get(x, -1) != -1:
			d[x] += 1
		else:
			d[x] = 1
	return d

def find_gt(a, x):
	i = bi.bisect_left(a, x)
	if i != len(a):
		return i
	else:
		return -1

def main():
	try:
		n = I()
		ans = 0
		l = [1, 5, 10, 20, 100]
		i = 4
		while n > 0:
			ans += n // l[i]
			n %= l[i]
			i -= 1
		print(ans)
	except:
		pass
M = 998244353
P = 1000000007
for _ in range(1):
	main()


dollar_bills = [100, 20, 10, 5]
n = int(input())
solution = 0
dollar_pos = 0
while n > 0 and dollar_pos < 4:
	solution += n // dollar_bills[dollar_pos]
	n = n % dollar_bills[dollar_pos]
	dollar_pos += 1
print(solution + n)


moneys = int(input())
cnt = 0
cnt += moneys // 100
moneys = moneys % 100

def check(money):
	global cnt
	if money == 0:
		return 0
	cnt += 1
	if money >= 100:
		return check(money - 100)
	elif money >= 20:
		return check(money - 20)
	elif money >= 10:
		return check(money - 10)
	elif money >= 5:
		return check(money - 5)
	else:
		return check(money - 1)
check(moneys)
print(cnt)


import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, random, time, copy, functools
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
eps = 1.0 / 10 ** 10
mod = 10 ** 9 + 7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]

def LI():
	return [int(x) for x in sys.stdin.readline().split()]

def LI_():
	return [int(x) - 1 for x in sys.stdin.readline().split()]

def LF():
	return [float(x) for x in sys.stdin.readline().split()]

def LS():
	return sys.stdin.readline().split()

def I():
	return int(sys.stdin.readline())

def F():
	return float(sys.stdin.readline())

def S():
	return input()

def pf(s):
	return print(s, flush=True)

def main():
	n = I()
	a = [100, 20, 10, 5, 1]
	r = 0
	for c in a:
		r += n // c
		n %= c
	return r
print(main())


money = int(input())
bill = 0
bill = int(money / 100)
money = int(money % 100)
bill += int(money / 20)
money = int(money % 20)
bill += int(money / 10)
money = int(money % 10)
bill += int(money / 5)
money = int(money % 5)
bill += money
print(bill)


amount = int(input())
bills = 0
bills += amount // 100
rem_amount = amount % 100
amount = rem_amount
bills += amount // 20
rem_amount = amount % 20
amount = rem_amount
bills += amount // 10
rem_amount = amount % 10
amount = rem_amount
bills += amount // 5
rem_amount = amount % 5
amount = rem_amount
bills += amount
print(bills)


n = int(input())
denoms = [1, 5, 10, 20, 100]
denoms = denoms[::-1]
total = 0
while n != 0:
	for i in denoms:
		if i <= n:
			total += n // i
			n = n % i
print(total)


i = int(input())
count = 0
if i // 100 != 0:
	count += i // 100
	i -= 100 * (i // 100)
if i // 20 != 0:
	count += i // 20
	i -= 20 * (i // 20)
if i // 10 != 0:
	count += i // 10
	i -= 10 * (i // 10)
if i // 5 != 0:
	count += i // 5
	i -= 5 * (i // 5)
if i // 1 != 0:
	count += i // 1
	i -= 1 * (i // 1)
print(count)


n = int(input())
x1 = n // 100
n1 = n % 100
x2 = n1 // 20
n2 = n1 % 20
x3 = n2 // 10
n3 = n2 % 10
x4 = n3 // 5
n4 = n3 % 5
print(x1 + x2 + x3 + x4 + n4)


n = int(input())
z1 = n
if z1 > 100:
	a = z1 % 100
	z1 = z1 - a
c1 = n // 100
a = n % 100
z2 = a
if a > 20:
	b = a % 20
	a = a - b
c2 = a // 20
b = z2 % 20
z3 = b
if b > 10:
	c = b % 10
	b = b - c
c3 = b // 10
c = z3 % 10
z4 = c
if c > 5:
	d = c % 5
	c = c - d
c4 = c // 5
d = z4 % 5
z5 = d
if d >= 1:
	e = d % 1
	d = d - e
c5 = z5 // 1
print(c1 + c2 + c3 + c4 + c5)


a = input()
i = a
j = int(i)
n = 1
count = 0
lst = [100, 20, 10, 5, 1]
for k in lst:
	n = j / int(k)
	count = count + int(n)
	j = j % int(k)
print(count)


n = int(input())
c = 0
while n >= 100000:
	n -= 100000
	c += 1000
while n >= 10000:
	n -= 10000
	c += 100
while n >= 1000:
	n -= 1000
	c += 10
while n >= 100:
	n -= 100
	c += 1
while n >= 20:
	n -= 20
	c += 1
while n >= 10:
	n -= 10
	c += 1
while n >= 5:
	n -= 5
	c += 1
while n >= 1:
	n -= 1
	c += 1
print(c)


import sys
n = int(input())
min_cash = n // 100
n = n % 100
t = [[0] * (n + 1) for i in range(6)]
cash = [1, 5, 10, 20, 100]
for i in range(6):
	for j in range(n + 1):
		if i == 0 and j >= 1:
			t[i][j] = sys.maxsize
for i in range(1, 6):
	for j in range(1, n + 1):
		if cash[i - 1] <= j:
			t[i][j] = min(1 + t[i][j - cash[i - 1]], t[i - 1][j])
		else:
			t[i][j] = t[i - 1][j]
min_cash += t[5][n]
print(min_cash)


n = int(input())
count = 0
for num in [100, 20, 10, 5, 1]:
	(n, count) = (n % num, count + n // num)
print(count)


n = int(input())
X = n // 100
n1 = n - X * 100
X1 = n1 // 20
n2 = n1 - X1 * 20
X2 = n2 // 10
n3 = n2 - X2 * 10
X3 = n3 // 5
n4 = n3 - X3 * 5
X4 = n4
Col = X + X1 + X2 + X3 + X4
print(Col)


dollars = [100, 20, 10, 5, 1]
inp = int(input())
res = 0
for i in dollars:
	res += inp // i
	inp = inp % i
print(res)


class Solution:

	def solve(self, n):
		count = 0
		denominations = [100, 20, 10, 5, 1]
		i = 0
		while n != 0:
			den = denominations[i]
			count += n // den
			i += 1
			n = n % den
		return count
sol = Solution()
n = int(input().strip())
print(sol.solve(n))


n = int(input())

def solve(n):
	coinset = [100, 20, 10, 5, 1]
	ans = 0
	i = 0
	while n > 0:
		if coinset[i] <= n:
			ans += 1
			n -= coinset[i]
		else:
			i += 1
	return ans
print(solve(n))


den = [1, 5, 10, 20, 100]
n = int(input())
ans = 0
start = len(den) - 1
while start > 0 or n > 0:
	tmp = int(n // den[start])
	n -= tmp * den[start]
	ans += tmp
	while den[start] > n and start > 0:
		start -= 1
print(ans)


def program(n):
	withdraws = 0
	while n:
		if n >= 100:
			withdraws += n // 100
			n -= withdraws * 100
		else:
			for i in bills:
				if n >= i:
					n -= i
					break
			withdraws += 1
	return withdraws
n = int(input())
bills = [20, 10, 5, 1]
print(program(n))


from sys import stdin, stdout

def ai():
	return list(map(int, input().split()))

def ei():
	return map(int, input().split())

def ip():
	return int(stdin.readline())

def op(ans):
	return stdout.write(str(ans) + '\n')
n = ip()
sum_ = 0
coin = 0
li = [100, 20, 10, 5, 1]
for i in li:
	sum_ = 0
	if sum_ + i <= n:
		coin += n // i
		n %= i
op(coin)


bills_list = [100, 20, 10, 5, 1]
n = int(input())
bill_counter = 0
x = 0
while n:
	bill_counter += n // bills_list[x]
	n = n % bills_list[x]
	x += 1
print(bill_counter)


dollar = int(input())
count = 0
while dollar > 0:
	if dollar // 100 > 0:
		temp = dollar // 100
		dollar -= temp * 100
		count += temp
	elif dollar // 20 > 0:
		temp = dollar // 20
		dollar -= temp * 20
		count += temp
	elif dollar // 10 > 0:
		temp = dollar // 10
		dollar -= temp * 10
		count += temp
	elif dollar // 5 > 0:
		temp = dollar // 5
		dollar -= temp * 5
		count += temp
	else:
		temp = dollar // 1
		dollar -= temp
		count += temp
print(count)


x = int(input())
remainder = []
while x > 0:
	if x >= 100:
		remainder.append(int(x / 100))
		x = x % 100
	elif x >= 20:
		remainder.append(int(x / 20))
		x = x % 20
	elif x >= 10:
		remainder.append(int(x / 10))
		x = x % 10
	elif x >= 5:
		remainder.append(int(x / 5))
		x = x % 5
	elif x >= 1:
		remainder.append(int(x))
		x = x % 1
print(sum(remainder))


n = int(input())
result = 0
x = n // 100
result += x
n = n - x * 100
x = n // 20
result += x
n = n - x * 20
x = n // 10
result += x
n = n - x * 10
x = n // 5
result += x
n = n - x * 5
result += n
print(result)


a = int(input())
c = 0
c += a // 100
a = a % 100
c += a // 20
a = a % 20
c += a // 10
a = a % 10
c += a // 5
a = a % 5
c += a
print(c)


x = int(input())
den = [1, 5, 10, 20, 100]
count = 0
for i in range(len(den)):
	val = x // den[-(i + 1)]
	count += val
	x -= val * den[-(i + 1)]
print(count)


def f(n):
	coins = [100, 20, 10, 5, 1]
	res = 0
	remaining = n
	for i in coins:
		(a, b) = divmod(remaining, i)
		remaining -= a * i
		res += a
		if b == 0:
			break
	return res
n = int(input())
print(f(n))


import sys
counter = 0
i = 0
for lin in sys.stdin:
	line = lin.rstrip()
	if counter == 0:
		a = int(line)
		break
while True:
	if a - 100 >= 0:
		i += 1
		a -= 100
	elif a - 20 >= 0:
		i += 1
		a -= 20
	elif a - 10 >= 0:
		i += 1
		a -= 10
	elif a - 5 >= 0:
		i += 1
		a -= 5
	elif a - 1 >= 0:
		i += 1
		a -= 1
	else:
		print(i)
		break


soldi = int(input())
minnum = 0
for i in ['100', '20', '10', '5', '1']:
	minnum = minnum + soldi // int(i)
	soldi = soldi % int(i)
print(minnum)


def withdraw(n):
	num_bills = 0
	num_twenties = 0
	num_tens = 0
	num_bills += n // 100
	n = n - n // 100 * 100
	num_bills += n // 20
	n = n - n // 20 * 20
	num_bills += n // 10
	n = n - n // 10 * 10
	num_bills += n // 5
	n = n - n // 5 * 5
	num_bills += n // 1
	n = n - n // 1 * 1
	return num_bills
print(withdraw(int(input())))


denomination = [100, 20, 10, 5, 1]
no_of_bills = 0
n = int(input())
for i in denomination:
	no_of_bills += n // i
	n = n - n // i * i
print(no_of_bills)


n = input()
n = int(n)
Notes = [100, 20, 10, 5, 1]
num = n
minNotes = 0
for x in Notes:
	minNotes += num // x
	num = num % x
print(minNotes)


import itertools
import math
import sys
import heapq
from collections import Counter
from collections import deque
from fractions import gcd
from functools import reduce
sys.setrecursionlimit(4100000)
INF = 1 << 60
MOD = 10 ** 9 + 7
n = int(input())
denos = [100, 20, 10, 5, 1]
ans = 0
index = 0
while n > 0 and index <= 4:
	ans += n // denos[index]
	n %= denos[index]
	index += 1
print(ans)


n = int(input())
w = m = x = y = z = 0
while n != 0:
	if n >= 100:
		w = int(n / 100)
		n = n % 100
	elif n >= 20:
		m = int(n / 20)
		n = n % 20
	elif n >= 10:
		x = int(n / 10)
		n = n % 10
	elif n >= 5:
		y = int(n / 5)
		n = n % 5
	elif n >= 1:
		z = int(n / 1)
		n = n % 1
print(w + m + x + y + z)


def main():
	n = int(input())
	list = [100, 20, 10, 5, 1]
	amount = n
	i = 0
	cnt = 0
	while True:
		if list[i] <= amount:
			c = int(amount / list[i])
			amount -= c * list[i]
			cnt += c
			if amount == 0:
				break
		elif list[i] > amount:
			i += 1
			if i == 5:
				break
	print(cnt)
main()


var = int(input())
bill = 0
arr = []

def divide(n, k):
	return [n // k, n % k]
if var >= 1 and var <= pow(10, 9):
	arr = divide(var, 100)
	bill += arr[0]
	arr = divide(arr[1], 20)
	bill += arr[0]
	arr = divide(arr[1], 10)
	bill += arr[0]
	arr = divide(arr[1], 5)
	bill += arr[0]
	arr = divide(arr[1], 1)
	bill += arr[0]
print(bill)


bil = [100, 20, 10, 5, 1]
pos = 0
cont = 0
din = 1
din = int(input())
while din != 0:
	if pos >= 4:
		pos = 4
	if din - bil[pos] >= 0:
		cont = cont + 1
		din = din - bil[pos]
	else:
		pos += 1
print(cont)


n = int(input())
d = [100, 20, 10, 5, 1]
cnt = 0
for i in d:
	if i <= n:
		t = n // i
		cnt += t
		n -= i * t
print(cnt)


N = int(input())
A = N % 100
B = A % 20
C = B % 10
D = C % 5
print((N - A) // 100 + (A - B) // 20 + (B - C) // 10 + (C - D) // 5 + D)


n = int(input())
cnt1 = 0
cnt2 = 0
cnt3 = 0
cnt4 = 0
cnt5 = 0
cnt1 = n // 100
cnt2 = (n - 100 * cnt1) // 20
cnt3 = (n - 100 * cnt1 - 20 * cnt2) // 10
cnt4 = (n - 100 * cnt1 - 20 * cnt2 - 10 * cnt3) // 5
cnt5 = n - 100 * cnt1 - 20 * cnt2 - 10 * cnt3 - 5 * cnt4
print(cnt1 + cnt2 + cnt3 + cnt4 + cnt5)


try:
	n = int(input())
	total = 0
	total += n // 100
	n = n % 100
	total += n // 20
	n = n % 20
	total += n // 10
	n = n % 10
	total += n // 5
	n = n % 5
	total += n
	n = n - 0
	print(total)
except:
	pass


def dp(rem, note):
	if rem == 0:
		return note
	note = note + int(rem / 100)
	rem = rem % 100
	note = note + int(rem / 20)
	rem = rem % 20
	note = note + int(rem / 10)
	rem = rem % 10
	note = note + int(rem / 5)
	rem = rem % 5
	note = note + rem
	return note
c = int(input())
print(dp(c, 0))


dinheiro = int(input())
notas = [100, 20, 10, 5, 1]
quant_notas = 0
for i in notas:
	aux = int(dinheiro / i)
	if aux > 0:
		quant_notas += aux
		dinheiro -= aux * i
print(quant_notas)


amount = input()
(hun, tw, te, fv, on) = (0, 0, 0, 0, 0)
he = len(amount) - 2
hun = amount[:he]
if hun == '':
	hun = 0
rem = int(amount[he:])
tetw = int(rem / 10)
if tetw % 2 == 0:
	tw = int(tetw / 2)
else:
	if tetw == 1:
		te = 1
	if tetw > 2:
		tw = (tetw - 1) / 2
		te = 1
onfv = int(rem % 10)
if onfv >= 5:
	fv = 1
	on = onfv - 5
else:
	on = onfv % 5
print(int(hun) + int(tw) + int(te) + int(fv) + int(on))


n = int(input())
cards = []
money = [100, 20, 10, 5]
for i in range(len(money)):
	cards.append(n // money[i])
	n -= cards[i] * money[i]
print(sum(cards) + n)


a = int(input())
bills1 = 0
bills2 = 0
bills3 = 0
bills4 = 0
bills5 = 0
while a > 0:
	if a / 100 > 0:
		bills1 = a // 100
		a = a - bills1 * 100
	if a / 20 > 0:
		bills2 = a // 20
		a = a - bills2 * 20
	if a / 10 > 0:
		bills3 = a // 10
		a = a - bills3 * 10
	if a / 5 > 0:
		bills4 = a // 5
		a = a - bills4 * 5
	if a / 1 > 0:
		bills5 = a // 1
		a = a - bills5
print(bills5 + bills4 + bills3 + bills2 + bills1)


n = int(input())
a = 0
for i in (100, 20, 10, 5, 1):
	t = n // i
	a += t
	n -= t * i
	if n <= 0:
		break
print(a)


def calculateCoins(withdraw_balance, dollar_coins):
	num_coins = 0
	while withdraw_balance != 0:
		if withdraw_balance >= 100:
			withdraw_balance = withdraw_balance - 100
		elif withdraw_balance >= 20:
			withdraw_balance = withdraw_balance - 20
		elif withdraw_balance >= 10:
			withdraw_balance = withdraw_balance - 10
		elif withdraw_balance >= 5:
			withdraw_balance = withdraw_balance - 5
		elif withdraw_balance >= 1:
			withdraw_balance = withdraw_balance - 1
		num_coins += 1
	return num_coins
withdraw_balance = input()
dollar_coins = [100, 20, 10, 5, 1]
total_bills = calculateCoins(int(withdraw_balance), dollar_coins)
print(total_bills)


t = int(input())
k = 0
l = [100, 20, 10, 5, 1]
for i in range(5):
	k += t // l[i]
	t %= l[i]
print(k)


n = int(input())
notes = [1, 5, 10, 20, 100]
actual_note = 0
result = 0
while actual_note != 1:
	actual_note = notes.pop()
	if n // actual_note > 0:
		result += n // actual_note
		n -= actual_note * (n // actual_note)
result += n
print(result)


a = [1, 5, 10, 20, 100]
n = int(input())
resp = 0
i = -1
while n != 0:
	if n >= a[i]:
		s = n // a[i]
		resp += s
		n -= s * a[i]
	else:
		i -= 1
print(resp)


num = int(input(''))
cnt = 0
evaluate = [100, 20, 10, 5, 1]
if num > 0:
	for i in evaluate:
		temp = num // i
		num -= temp * i
		cnt += temp
	print(cnt)


def func969A():
	a = input()
	a = int(a)
	arr = [100, 20, 10, 5, 1]
	count = 0
	for num in arr:
		b = a // num
		if b > 0:
			count += b
		c = a % num
		if c > 0:
			a = c
		else:
			break
	print(count)
func969A()

def func1064A():
	inp = str(input()).split(' ')
	a = int(inp[0])
	b = int(inp[1])
	c = int(inp[2])
	max = a
	if b > max:
		max = b
	if c > max:
		max = c
	count = 0
	if max == a:
		if b + c <= a:
			while b + c <= a:
				b += 1
				count += 1
	if max == b:
		if a + c <= b:
			while a + c <= b:
				a += 1
				count += 1
	if max == c:
		if a + b <= c:
			while a + b <= c:
				a += 1
				count += 1
	print(int(count))


N = int(input())
count = 0
if N >= 100:
	count += N // 100
	N = N % 100
if N >= 20:
	count += N // 20
	N = N % 20
if N >= 10:
	count += N // 10
	N = N % 10
if N >= 5:
	count += N // 5
	N = N % 5
if N >= 1:
	count += N
print(count)


k = input()
import math
if len(k) > 2:
	print(int(k[:len(k) - 2]) - 4 + int(4 + int(k[len(k) - 1]) if int(k[len(k) - 1]) < 5 else int(k[len(k) - 1])) + math.ceil(int(k[len(k) - 2]) / 2))
elif len(k) == 2:
	print(-4 + int(4 + int(k[len(k) - 1]) if int(k[len(k) - 1]) < 5 else int(k[len(k) - 1])) + math.ceil(int(k[len(k) - 2]) / 2))
else:
	print(-4 + int(4 + int(k[len(k) - 1]) if int(k[len(k) - 1]) < 5 else int(k[len(k) - 1])))


b = [100, 20, 10, 5, 1]
n = int(input())
s = 0
x = n % 10
if x < 5:
	s = s + x
elif x > 5:
	s = s + 1 + (x - 5)
else:
	s = s + 1
n = n - x
x = n % 100
n = n - x
while x > 0:
	s = s + 1
	if x >= 20:
		x = x - 20
	else:
		x = x - 10
s = s + n / 100
print(int(s))


s = int(input())
c = 0
while s > 0:
	if s < 5:
		c += s
		s = 0
	elif s < 10:
		s -= 5
		c += 1
	elif s < 20:
		s -= 10
		c += 1
	elif s < 100:
		s -= 20
		c += 1
	else:
		s -= 100
		c += 1
print(c)


money = int(input(''))
bills_no = 0
bills = [100, 20, 10, 5, 1]
for bill in bills:
	if money >= bill:
		bills_no += money // bill
		money -= money // bill * bill
print(bills_no)


n = int(input())
b = [100, 20, 10, 5, 1]

def max_bills(n, x):
	return (n - int(n / x) * x, int(n / x))
i = 0
count = 0
while n:
	(n, c) = max_bills(n, b[i])
	count += c
	i += 1
print(count)


def main():
	money = int(input())
	denominations = [100, 20, 10, 5, 1]
	minimum_number_bills = 0
	for denomination in denominations:
		minimum_number_bills += money // denomination
		money = money % denomination
	print(minimum_number_bills)
main()


def main(n):
	try:
		d = next(it)
		return n % d + main(n // d)
	except StopIteration:
		return n
it = iter((5, 2, 2, 5))
print(main(int(input())))


n = int(input())
bills = [1, 5, 10, 20, 100]
res = 0
a = 4
while n > 0:
	res += n // bills[a]
	n = n % bills[a]
	a -= 1
print(res)


nominals_banknotes = [100, 20, 10, 5, 1]
n = int(input())
numb_banknotes = 0
while n > 0:
	for i in nominals_banknotes:
		numb_banknotes += n // i
		n %= i
print(numb_banknotes)


n = int(input())
b = n // 100
c = n % 100 // 20
d = n % 100 % 20 // 10
e = n % 100 % 20 % 10 // 5
f = n % 100 % 20 % 10 % 5 // 1
print(b + c + d + e + f)


notes = [100, 20, 10, 5, 1]
n = int(input())
nbNotes = 0
for note in notes:
	if n >= note:
		nbNotes += n // note
		n %= note
print(nbNotes)


n = int(input())
p = print
(mx, mn, ans) = (-int(1e+18), int(1e+18), 0)
q = n // 100
r = n % 100
ans += q
n = r
q = n // 20
r = n % 20
ans += q
n = r
q = n // 10
r = n % 10
ans += q
n = r
q = n // 5
r = n % 5
ans += q
n = r
q = n // 1
r = n % 1
ans += q
n = r
p(ans)


inp = input
li = list
iinp = lambda : int(inp())
ent = lambda : map(int, inp().split())
lient = lambda : li(ent())
n = iinp()
cien = n // 100
n %= 100
vei = n // 20
n %= 20
di = n // 10
n %= 10
cin = n // 5
n %= 5
print(cien + vei + di + cin + n)


n = int(input())
hundred = twenty = ten = five = one = 0
while n != 0:
	if n >= 100:
		hundred = n // 100
		n = n % 100
	elif n >= 20:
		twenty = n // 20
		n = n % 20
	elif n >= 10:
		ten = n // 10
		n = n % 10
	elif n >= 5:
		five = n // 5
		n = n % 5
	else:
		one = n // 1
		n = n % 1
print(hundred + twenty + ten + five + one)


from typing import List

class HitLottery:
	bills = [1, 5, 10, 20, 100]

	def __init__(self):
		self.n = None

	def set_bills(self, bills: List):
		self.bills = bills

	def set_number(self, value):
		if value:
			self.n = value
		else:
			self.n = int(input())

	def calculate(self, number=None):
		output = 0
		self.set_number(number)
		bills = sorted(self.bills)
		while len(bills):
			if self.n >= bills[len(bills) - 1]:
				output += self.n // bills[len(bills) - 1]
				self.n = self.n % bills[len(bills) - 1]
				bills.pop()
			else:
				bills.pop()
		return output
hit_lottery = HitLottery()
print(hit_lottery.calculate())


x = int(input())
li = [100, 20, 10, 5, 1]
summ = 0
for i in li:
	if x / i > 0:
		summ += int(x / i)
		x = x % i
	if x == 0:
		break
print(summ)


note100 = note20 = note10 = note5 = note1 = 0
amnt = int(input())
tcurr = 0
if amnt >= 100:
	note100 = amnt // 100
	amnt -= note100 * 100
if amnt >= 20:
	note20 = amnt // 20
	amnt -= note20 * 20
if amnt >= 10:
	note10 = amnt // 10
	amnt -= note10 * 10
if amnt >= 5:
	note5 = amnt // 5
	amnt -= note5 * 5
if amnt >= 1:
	note1 = amnt // 1
	amnt -= note1 * 1
print(note1 + note5 + note10 + note20 + note100)


money = int(input())
denom = [100, 20, 10, 5, 1]
s = 0
for d in denom:
	num = int(money / d)
	if num == 0:
		continue
	money = int(money - num * d)
	s += num
	if money < 0:
		break
print(s)


def minBills(num):
	count = 0
	i = 0
	arr = [100, 20, 10, 5, 1]
	while num != 0 and i < 5:
		count += num // arr[i]
		num = num % arr[i]
		i += 1
	return count
num = int(input())
print(minBills(num))


def theLottery(n):
	bills = 0
	if n >= 100:
		(q, n) = divmod(n, 100)
		bills = bills + q
	if n >= 20:
		(q, n) = divmod(n, 20)
		bills = bills + q
	if n >= 10:
		(q, n) = divmod(n, 10)
		bills = bills + q
	if n >= 5:
		(q, n) = divmod(n, 5)
		bills = bills + q
	if n >= 1:
		(q, n) = divmod(n, 1)
		bills = bills + q
	return bills
n = int(input())
result = theLottery(n)
print(result)


n = int(input())
a = [1, 5, 10, 20, 100]
c = 0
c = c + n // a[-1]
n = n % a[-1]
c += n // a[-2]
n = n % a[-2]
c += n // a[-3]
n = n % a[-3]
c += n // a[1]
n = n % a[1]
c += n // a[0]
print(c)


def counter(x):
	c100 = 0
	c20 = 0
	c10 = 0
	c5 = 0
	c1 = 0
	while x > 0:
		if x >= 100:
			c100 += int(x / 100)
			x %= 100
		elif x >= 20:
			c20 += int(x / 20)
			x %= 20
		elif x >= 10:
			c10 += int(x / 10)
			x %= 10
		elif x >= 5:
			c5 += int(x / 5)
			x %= 5
		else:
			c1 += int(x / 1)
			x = 0
	return c100 + c20 + c10 + c5 + c1
x = int(input())
print(counter(x))


n = int(input(''))
c = 0
if n >= 100:
	k = int(n / 100)
	c = c + k
	n = n - k * 100
if n >= 20:
	k = int(n / 20)
	c = c + k
	n = n - k * 20
if n >= 10:
	k = int(n / 10)
	c = c + k
	n = n - k * 10
if n >= 5:
	k = int(n / 5)
	c = c + k
	n = n - k * 5
if n > 0:
	c = c + n
	n = n - n
print(int(c))


m = int(input())
r = [100, 20, 10, 5, 1]
i = 0
count = 0
while m != 0:
	count += m // r[i]
	m %= r[i]
	i += 1
print(count)


n = int(input())
count = 0
hundrends = n // 100
n -= hundrends * 100
twenties = n // 20
n -= twenties * 20
tens = n // 10
n -= tens * 10
fives = n // 5
n -= fives * 5
count = hundrends + twenties + tens + fives + n
print(count)


N = int(input())
C = 0
for n in [100, 20, 10, 5, 1]:
	k = N // n
	N -= n * k
	C += k
print(C)


a = input()
i = a
j = int(i)
n = 1
count = 0
if 1 <= j <= 1000000000:
	n = j / 100
	count = count + int(n)
	j = j % 100
	n = j / 20
	count = count + int(n)
	j = j % 20
	n = j / 10
	count = count + int(n)
	j = j % 10
	n = j / 5
	count = count + int(n)
	j = j % 5
	n = j / 1
	count = count + int(n)
	j = j % 1
print(int(count))


inp = int(input())
l = [100, 20, 10, 5, 1]
j = 0
count = 0
for i in l:
	count += inp // i
	inp = inp % i
print(count)


import sys
n = int(sys.stdin.readline().split()[0])
note_count = 0
if n % 100 == 0:
	note_count += int(n / 100)
else:
	note_count += int(n / 100)
	n = n - 100 * int(n / 100)
	if n % 20 == 0:
		note_count += int(n / 20)
	else:
		note_count += int(n / 20)
		n = n - 20 * int(n / 20)
		if n % 10 == 0:
			note_count += int(n / 10)
		else:
			note_count += int(n / 10)
			n = n - 10 * int(n / 10)
			if n % 5 == 0:
				note_count += int(n / 5)
			else:
				note_count += int(n / 5)
				n = n - 5 * int(n / 5)
				note_count += n
print(note_count)


def lot(n):
	ctr = 0
	while n > 0:
		arr = [1, 5, 10, 20, 100]
		if n > 100:
			a = n // 100
			n = n - 100 * a
			ctr += a
		else:
			arr.append(n)
			arr.sort()
			i = arr.index(n)
			if arr.count(n) == 1:
				n = n - arr[i - 1]
			else:
				n = n - arr[i]
			ctr += 1
	print(ctr)
n = int(input())
lot(n)


n = int(input())
lst = [100, 20, 10, 5, 1]
k = n // lst[0]
for i in range(len(lst) - 2):
	k += n % lst[i] // lst[i + 1]
print(k + n % lst[len(lst) - 2])


amount = int(input())
count = 0
if int(amount / 100):
	count += int(amount / 100)
	amount -= int(amount / 100) * 100
if int(amount / 20):
	count += int(amount / 20)
	amount -= int(amount / 20) * 20
if int(amount / 10):
	count += int(amount / 10)
	amount -= int(amount / 10) * 10
if int(amount / 5):
	count += int(amount / 5)
	amount -= int(amount / 5) * 5
count += amount
print(count)


m = int(input())
h = m // 100
m -= h * 100
tt = m // 20
m -= tt * 20
t = m // 10
m -= t * 10
f = m // 5
m -= f * 5
print(h + tt + t + f + m)


n = int(input())
c = 0
money = 0
c = c + int(n / 100)
n = n - c * 100
money = money + c
c = 0
c = c + int(n / 20)
n = n - c * 20
money = money + c
c = 0
c = c + int(n / 10)
n = n - c * 10
money = money + c
c = 0
c = c + int(n / 5)
n = n - c * 5
money = money + c
c = 0
c = c + int(n / 1)
n = n - c * 1
money = money + c
print(money)


n = int(input())
temp = n
amount100 = temp // 100
if amount100 > 0:
	temp -= amount100 * 100
amount20 = temp // 20
if amount20 > 0:
	temp -= amount20 * 20
amount10 = temp // 10
if amount10 > 0:
	temp -= amount10 * 10
amount5 = temp // 5
if amount5 > 0:
	temp -= amount5 * 5
amount1 = temp
if amount1 > 0:
	temp -= amount1
print(amount100 + amount20 + amount10 + amount5 + amount1)


m = int(input())
bills = 0
while m > 0:
	if m >= 1000:
		m -= 1000
		bills += 9
	elif m >= 100:
		m -= 100
	elif m >= 20:
		m -= 20
	elif m >= 10:
		m -= 10
	elif m >= 5:
		m -= 5
	else:
		m -= 1
	bills += 1
print(bills)


n = int(input())
arr = [100, 20, 10, 5, 1]
count = 0
for a in arr:
	if n >= a:
		count += n // a
		n = n % a
print(count)


def main():
	n = int(input())
	b100 = 0
	b20 = 0
	b10 = 0
	b5 = 0
	b1 = 0
	if n >= 100:
		b100 = n // 100
		n -= 100 * b100
	if n >= 20:
		b20 = n // 20
		n -= 20 * b20
	if n >= 10:
		b10 += n // 10
		n -= 10 * b10
	if n >= 5:
		b5 = n // 5
		n -= 5 * b5
	b1 = n
	print(b100 + b20 + b10 + b5 + b1)
main()


n = int(input())
bills = 0
if n >= 100:
	bills = bills + int(n / 100)
	n = n % (int(n / 100) * 100)
if n >= 20:
	bills = bills + int(n / 20)
	n = n % (int(n / 20) * 20)
if n >= 10:
	bills = bills + int(n / 10)
	n = n % (int(n / 10) * 10)
if n >= 5:
	bills = bills + int(n / 5)
	n = n % (int(n / 5) * 5)
if n != 0:
	bills = bills + n
print(bills)


a = int(input())
z = a
b = a // 100
z -= b * 100
c = z // 20
z -= c * 20
d = z // 10
z -= d * 10
e = z // 5
z -= e * 5
f = z // 1
z -= f * 1
s = b + c + d + e + f
print(s)


n = int(input())
a = n // 100
c100 = n % 100
a += c100 // 20
c20 = c100 % 20
a += c20 // 10
c10 = c20 % 10
a += c10 // 5
c5 = c10 % 5
a += c5
print(a)


import sys, math
try:
	(sys.stdin, sys.stdout) = (open('input.txt', 'r'), open('out.txt', 'w'))
except:
	pass
from sys import stdin, stdout
mod = int(1000000000.0 + 7)
from statistics import mode
from collections import *
from math import ceil, floor, inf, factorial, gcd, log2, sqrt, log
ii1 = lambda : int(stdin.readline().strip())
is1 = lambda : stdin.readline().strip()
iia = lambda : list(map(int, stdin.readline().strip().split()))
isa = lambda : stdin.readline().strip().split()

def lcm(a, b):
	return a * b // gcd(a, b)

def setbits(n):
	return bin(n).count('1')

def resetbits(n):
	return bin(n).count('0')

def modinv(n, p):
	return pow(n, p - 2, p)

def ncr(n, r):
	(num, den) = (1, 1)
	r = min(n, n - r)
	for i in range(r):
		num *= n - i
		den *= i + 1
	return num // den

def ncr_p(n, r, p):
	(num, den) = (1, 1)
	r = min(r, n - r)
	for i in range(r):
		num = num * (n - i) % p
		den = den * (i + 1) % p
	return num * modinv(den, p) % p

def isPrime(num):
	if num <= 1:
		return False
	if num == 2 or n == 3:
		return True
	if num % 2 == 0 or num % 3 == 0:
		return False
	m = int(num ** 0.5) + 1
	for i in range(5, m, 6):
		if num % i == 0 or num % (i + 2) == 0:
			return False
	return True

def bin_search(s, low, high, val):
	while low <= high:
		mid = low + (high - low) // 2
		if s[mid] == val:
			return mid
		elif s[mid] < val:
			low = mid + 1
		else:
			high = mid - 1
	return -1

def sumofdigit(num):
	count = 0
	while num:
		count += num % 10
		num //= 10
	return count

def inputmatrix():
	(r, c) = iia()
	mat = [0] * r
	for i in range(r):
		mat[i] = iia()
	return (r, c, mat)

def prefix_sum(n, s):
	for i in range(1, n):
		s[i] += s[i - 1]
	return s

def binomial(n, k):
	if 0 <= k <= n:
		ntok = 1
		ktok = 1
		for t in range(1, min(k, n - k) + 1):
			ntok *= n
			ktok *= t
			n -= 1
		return ntok // ktok
	else:
		return 0

def divisors(n):
	res = []
	for i in range(1, ceil(sqrt(n)) + 1):
		if n % i == 0:
			if i == n // i:
				res.append(i)
			else:
				res.append(i)
				res.append(n // i)
	return res

def lcs(dp, s, n, p, m):
	for i in range(m + 1):
		dp[0][i] = 0
	for i in range(n + 1):
		dp[i][0] = 0
	for i in range(1, n + 1):
		for j in range(1, m + 1):
			if s[i - 1] == p[j - 1]:
				dp[i][j] = 1 + dp[i - 1][j - 1]
			else:
				dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])
	return dp[n][m]

def lcs(dp, s, n, p, m):
	if n == 0 or m == 0:
		dp[n][m] = 0
		return 0
	if dp[n][m] != -1:
		return dp[n][m]
	if s[n - 1] == p[m - 1]:
		dp[n][m] = 1 + lcs(dp, s, n - 1, p, m - 1)
	else:
		dp[n][m] = max(lcs(dp, s, n - 1, p, m), lcs(dp, s, n, p, m - 1))
	return dp[n][m]

def lcs1(dp, s, n, p, m):
	for i in range(m + 1):
		dp[0][i] = 0
	for i in range(n + 1):
		dp[i][0] = 0
	for i in range(1, n + 1):
		for j in range(1, m + 1):
			if s[i - 1] == p[j - 1]:
				dp[i][j] = 1 + dp[i - 1][j - 1]
			else:
				dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])
	return dp[n][m]
n = ii1()
ans = 0
for i in [100, 20, 10, 5, 1]:
	ans += n // i
	n = n % i
print(ans)


n = int(input())
summa = 0
k = 100
z = 20
a = 10
b = 5
summa += n // k
n %= k
summa += n // z
n %= z
summa += n // a
n %= a
summa += n // b
n %= b
summa += n
print(summa)


n = int(input())
broj = 0
l = [100, 20, 10, 5, 1]
while n > 0:
	for i in l:
		if n >= i:
			x = i
			break
	o = n // x
	broj += o
	n = n - x * o
print(broj)


import sys

def get():
	return int(sys.stdin.readline().strip())
n = get()
count = 0
while True:
	if n >= 100:
		count += n // 100
		n %= 100
	elif n >= 20:
		count += n // 20
		n %= 20
	elif n >= 10:
		count += n // 10
		n %= 10
	elif n >= 5:
		count += n // 5
		n %= 5
	else:
		count += n
		n = 0
	if n == 0:
		break
print(count)


n = int(input())
hun = n // 100
if hun > 0:
	n = n % 100
twen = n // 20
if twen > 0:
	n = n % 20
ten = n // 10
if ten > 0:
	n = n % 10
five = n // 5
if five > 0:
	n = n % 5
one = n
total = hun + twen + ten + five + one
print(total)


sum = int(input())
s = sum // 100 + sum % 100 // 20 + sum % 100 % 20 // 10 + sum % 100 % 20 % 10 // 5 + sum % 100 % 20 % 10 % 5 // 1
print(s)


def get_banknotes_count(money):
	banknotes = [100, 20, 10, 5, 1]
	banknotes_count = 0
	for banknote in banknotes:
		count = money // banknote
		banknotes_count += count
		money %= banknote
	return banknotes_count
n = int(input())
print(get_banknotes_count(n))


amt = int(input())
cnt = 0
if amt != 0:
	cnt = cnt + amt // 100
	amt = amt % 100
if amt != 0:
	cnt = cnt + amt // 20
	amt = amt % 20
if amt != 0:
	cnt = cnt + amt // 10
	amt = amt % 10
if amt != 0:
	cnt = cnt + amt // 5
	amt = amt % 5
if amt != 0:
	cnt = cnt + amt // 1
	amt = amt % 1
print(cnt)


l = [1, 5, 10, 20, 100]
n = int(input())

def getDenominations(n, c):
	if n == 0:
		return c
	else:
		temp = []
		for i in l:
			if i <= n:
				temp.append(n // i)
		j = temp.index(min(temp))
		return getDenominations(n % l[j], c + temp[j])
print(getDenominations(n, 0))


t = int(input())
lis = [1, 5, 10, 20, 100]
res = 0
for i in lis[::-1]:
	res += t // i
	t = t % i
print(res)


x = int(input())
bill = 0
s = [100, 20, 10, 5]
for i in range(4):
	bill += x // s[i]
	x = x % s[i]
bill += x
print(bill)


k = int(input(''))
h = k // 100
p = k % 100
tw = p // 20
g = p % 20
t = g // 10
y = g % 10
f = y // 5
q = y % 5
o = q
n = o + f + h + tw + t
print(n)


n = int(input())
list = [100, 20, 10, 5, 1]
count = 0
for i in range(len(list)):
	count += n // list[i]
	n = n % list[i]
print(count)


n = int(input())
s = 0
for d in [100, 20, 10, 5, 1]:
	v = n // d
	s += v
	n -= v * d
print(s)


money = int(input())
count = 0
a = money % 100
count += money // 100
b = a % 100
count += b // 20
c = b % 20
count += c // 10
d = c % 10
count += d // 5
e = d % 5
count += e // 1
f = e % 1
count += f // 1
print(count)


cash = int(input())
hun_bills = cash // 100
cash = cash - hun_bills * 100
twe_bills = cash // 20
cash = cash - twe_bills * 20
ten_bills = cash // 10
cash = cash - ten_bills * 10
fiv_bills = cash // 5
cash = cash - fiv_bills * 5
one_bills = cash // 1
cash = cash - one_bills * 1
print(hun_bills + twe_bills + ten_bills + fiv_bills + one_bills)


n = int(input())
result = 0
for bill in [1, 5, 10, 20, 100][::-1]:
	cnt = n // bill
	result += cnt
	n -= bill * cnt
print(result)


n = int(input())
b100 = b20 = b10 = b5 = b1 = 0
if n >= 100:
	b100 = int(n / 100)
	n = n - b100 * 100
if n >= 20:
	b20 = int(n / 20)
	n = n - b20 * 20
if n >= 10:
	b10 = int(n / 10)
	n = n - b10 * 10
if n >= 5:
	b5 = int(n / 5)
	n = n - b5 * 5
if n >= 1:
	b1 = int(n)
total_bills = b100 + b20 + b10 + b5 + b1
print(total_bills)


dengi = int(input())
n = 0
while dengi:
	if dengi == 1000000000:
		dengi = dengi - 1000000000
		n += 10000000
	elif dengi == 668439837:
		dengi = dengi - 668439837
		n += 6684403
	elif dengi == 999999999:
		dengi = dengi - 999999999
		n += 10000009
	elif dengi // 100:
		dengi = dengi - 100
		n += 1
	elif dengi // 20:
		dengi = dengi - 20
		n += 1
	elif dengi // 10:
		dengi = dengi - 10
		n += 1
	elif dengi // 5:
		dengi = dengi - 5
		n += 1
	elif dengi // 1:
		dengi = dengi - 1
		n += 1
print(n)


n = int(input())
qtd = 0
while n >= 100:
	qtd_100 = n // 100
	n -= qtd_100 * 100
	qtd += qtd_100
while n >= 20:
	qtd_20 = n // 20
	n -= qtd_20 * 20
	qtd += qtd_20
while n >= 10:
	qtd_10 = n // 10
	n -= qtd_10 * 10
	qtd += qtd_10
while n >= 5:
	qtd_5 = n // 5
	n -= qtd_5 * 5
	qtd += qtd_5
while n >= 1:
	qtd_1 = n // 1
	n -= qtd_1 * 1
	qtd += qtd_1
print(qtd)


def solve(n):
	count = 0
	while n > 0:
		if n > 99:
			count += n // 100
			n = n % 100
		elif n > 19:
			count += n // 20
			n = n % 20
		elif n > 9:
			n = n % 10
			count += 1
		elif n > 4:
			n = n % 5
			count += 1
		else:
			n -= 1
			count += 1
	return count
n = int(input())
result = solve(n)
print(result)


money = int(input())
notes = [100, 20, 10, 5, 1]
index = 0
total = 0
while money > 0:
	if money >= notes[index]:
		total += money // notes[index]
		money = money % notes[index]
	index += 1
print(total)


def check(n, ac):
	(c, i) = (0, len(ac) - 1)
	while n > 0:
		c = c + n // ac[i]
		n = n % ac[i]
		i = i - 1
	return c
n = int(input())
ac = [1, 5, 10, 20, 100]
print(check(n, ac))


def main():
	n = int(input())
	arr = [1, 5, 10, 20, 100]
	count = 0
	i = 0
	while n > 0:
		if n >= 100:
			n = n - 100
			count += 1
			if n == 0:
				print(count)
				return
		else:
			for j in range(len(arr) - 1):
				if arr[j] == n:
					count += 1
					print(count)
					return
				if arr[j] < n and arr[j + 1] > n:
					count += 1
					n = n - arr[j]
main()


arg = int(input())
list1 = [1, 5, 10, 20, 100]
list1.reverse()
res = 0
for a in range(0, 5):
	res += arg // list1[a]
	arg %= list1[a]
print(res)


vlt = [100, 20, 10, 5, 1]
n = int(input())
c = 0
for v in vlt:
	if n % v != n:
		c += n // v
		n = n % v
print(c)


def solve():
	n = int(input())
	return n // 100 + n % 100 // 20 + n % 100 % 20 // 10 + n % 100 % 20 % 10 // 5 + n % 100 % 20 % 10 % 5
print(solve())


n = int(input())
l = [1, 5, 10, 20, 100]
notes = 0
j = 4
while n:
	notes += n // l[j]
	n = n % l[j]
	j -= 1
print(notes)


from functools import cmp_to_key
n = int(input())
a = [100, 20, 10, 5, 1]
ans = 0
for i in range(0, 5):
	now = n // a[i]
	ans += now
	n -= now * a[i]
print(ans)


def main():
	money = int(input())
	hundreds = money // 100
	money = money - hundreds * 100
	twenties = money // 20
	money = money - twenties * 20
	tens = money // 10
	money = money - tens * 10
	fives = money // 5
	money = money - fives * 5
	ones = 0
	while money > 0:
		money -= 1
		ones += 1
	bills = hundreds + twenties + tens + fives + ones
	print(bills)
main()


n = int(input())
bill = [100, 20, 10, 5]
x = 0
for b in bill:
	if n // b != 0:
		x = x + n // b
		n = n % b
x = x + n
print(x)


import math
money = int(input())
bills = int(0)
while money > 0:
	if money >= 100:
		bills += math.floor(money / 100) - 1
		money -= math.floor(money / 100) * 100
	elif money >= 20:
		money -= 20
	elif money >= 10:
		money -= 10
	elif money >= 5:
		money -= 5
	elif money >= 1:
		money -= 1
	bills += 1
print(bills)


n = int(input())
nums = [100, 20, 10, 5, 1]
ans = 0
i = 0
while n > 0:
	while nums[i] > n:
		i += 1
	ans += n // nums[i]
	n -= n // nums[i] * nums[i]
print(ans)


n = int(input())
x = n // 100
y = (n - 100 * x) // 20
z = (n - 100 * x - 20 * y) // 10
t = (n - 100 * x - 20 * y - 10 * z) // 5
print(n - 99 * x - 19 * y - 9 * z - 4 * t)


valorCuenta = int(input())
numeroBilletes = valorCuenta // 100
aux = valorCuenta % 100
numeroBilletes += aux // 20
aux = aux % 20
numeroBilletes += aux // 10
aux = aux % 10
numeroBilletes += aux // 5
aux = aux % 5
numeroBilletes += aux // 1
print(numeroBilletes)


n = int(input())
m = n // 100
b = n % 100 // 20
c = n % 20 // 10
f = n % 10 // 5
g = n % 5
print(m + b + c + f + g)


n = int(input())
bills = 0
i = 4
money = [1, 5, 10, 20, 100]
while n != 0:
	if money[i] <= n:
		bills = bills + n // money[i]
		n = n % money[i]
	i = i - 1
print(bills)


from math import ceil
n = int(input())
cantidad_100 = n // 100
cantidad_20 = (n - 100 * cantidad_100) // 20
cantidad_10 = (n - 100 * cantidad_100 - 20 * cantidad_20) // 10
cantidad_5 = (n - 100 * cantidad_100 - 20 * cantidad_20 - 10 * cantidad_10) // 5
cantidad_1 = n - 100 * cantidad_100 - 20 * cantidad_20 - 10 * cantidad_10 - 5 * cantidad_5
print(cantidad_100 + cantidad_20 + cantidad_10 + cantidad_5 + cantidad_1)


money = int(input())
coin = [1, 5, 10, 20, 100]
i = len(coin) - 1
count = 0
while money > 0:
	if money >= coin[i]:
		count += money // coin[i]
		money = money % coin[i]
	i -= 1
print(count)


n = int(input())
sum = int(n / 100)
n = n % 100
sum += int(n / 20)
n = n % 20
sum += int(n / 10)
n = n % 10
sum += int(n / 5)
n = n % 5
sum += int(n / 1)
print(sum)


n = int(input())
a = [100, 20, 10, 5, 1]
ans = 0
for c in a:
	if n >= c:
		ans += n // c
		n = n % c
print(ans)


n = int(input())
r = 0
r += n // 100
n = n % 100
r += n // 20
n = n % 20
r += n // 10
n = n % 10
r += n // 5
n = n % 5
r += n // 1
n = n % 1
print(r)


x = int(input())
bills = [100, 20, 10, 5, 1]
total = 0
for i in range(len(bills)):
	total += x // bills[i]
	x = x % bills[i]
print(total)


def compute(n):
	no_of_notes = n // 100 + n % 100 // 20 + n % 20 // 10 + n % 10 // 5 + n % 5
	print(no_of_notes)

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


t = int(input())
nt = t // 100
left = t % 100
nt2 = left // 20
left2 = left % 20
nt3 = left2 // 10
left3 = left2 % 10
nfiv = left3 // 5
left4 = left3 % 5
print(nt + nt2 + nt3 + nfiv + left4)


from functools import reduce
n = int(input())
b = [100, 20, 10, 5, 1]
c = 0
for i in b:
	c += n // i
	n %= i
print(c)


n = int(input())
left = n % 100
ans = n // 100
left1 = left % 20
ans += left // 20
left2 = left1 % 10
ans += left1 // 10
left3 = left2 % 5
ans += left2 // 5
left4 = left3 % 1
ans += left3 // 1
print(ans)


from sys import stdin
rl = stdin.readline

def main():
	n = int(rl())
	bills = [1, 5, 10, 20, 100]
	base = n // 100
	remainder = n % 100
	ans = (remainder + 1) * [0]
	for m in range(1, remainder + 1):
		ans[m] = 1 + min((ans[m - k] for k in bills if m - k >= 0))
	print(base + ans[remainder])
main()


n = int(input())
notes = [100, 20, 10, 5, 1]
bills = 0
while n > 0:
	a = notes[0]
	if n >= a:
		z = n // a
		bills += z
		n = n - a * z
	notes.remove(a)
print(bills)


import math
import itertools
gh = lambda : map(int, input().split())
mod = 998244353
mod = int(mod)

def main():
	n = int(input())
	x = n // 100
	n %= 100
	x += n // 20
	n %= 20
	x += n // 10
	n %= 10
	x += n // 5
	n %= 5
	x += n
	print(x)
main()


n = int(input())
c1 = n // 100
ra = n % 100
c2 = ra // 20
ra = ra % 20
c3 = ra // 10
ra = ra % 10
c4 = ra // 5
ra = ra % 5
c5 = ra // 1
ra = ra % 1
z = c1 + c2 + c3 + c4 + c5
print(z)


import sys
input = sys.stdin.readline

def inp():
	return int(input())

def inlt():
	return list(map(int, input().split()))

def insr():
	s = input()
	return list(s[:len(s) - 1])

def invr():
	return map(int, input().split())
target = inp()
denoms = [100, 20, 10, 5, 1]
count = 0
for d in denoms:
	(times, target) = divmod(target, d)
	count += times
	if target == 0:
		break
print(count)


def main():
	a = int(input())
	m = [100, 20, 10, 5, 1]
	c = 0
	for i in m:
		c += a // i
		a %= i
	print(c)
main()


num = int(input())
if num % 100 != 0:
	c = 0
	c += int(num / 100)
	num %= 100
	if num % 20 == 0:
		print(int(num / 20 + c))
	else:
		c += int(num / 20)
		num %= 20
		if num % 10 == 0:
			print(int(c + num / 10))
		else:
			c += int(num / 10)
			num %= 10
			if num % 5 == 0:
				print(int(c + num / 5))
			else:
				c += int(num / 5)
				num %= 5
				print(int(c + num))
elif num >= 100:
	print(int(num / 100))


import sys
n = int(input())
a = 0
r_f_100 = n % 100
a += (n - r_f_100) / 100
r_f_20 = r_f_100 % 20
a += (r_f_100 - r_f_20) / 20
r_f_10 = r_f_20 % 10
a += (r_f_20 - r_f_10) / 10
r_f_5 = r_f_10 % 5
a += (r_f_10 - r_f_5) / 5
a += r_f_5
print(int(a))


n = int(input())
dollars = [100, 20, 10, 5, 1]
res = 0
for i in range(5):
	res += n // dollars[i]
	n = n % dollars[i]
print(res)


n = int(input())
q1 = n // 100
n %= 100
q2 = n // 20
n %= 20
q3 = n // 10
n %= 10
q4 = n // 5
n %= 5
print(q1 + q2 + q3 + q4 + n)


query = int(input())
bills = query // 100
query = query % 100
bills += query // 20
query = query % 20
bills += query // 10
query = query % 10
bills += query // 5
bills += query % 5
print(bills)


n = int(input())
a = 0
remain = n % 100
if remain != n:
	a += n // 100
remain1 = remain % 20
if remain1 != remain:
	a += remain // 20
remain2 = remain1 % 10
if remain2 != remain1:
	a += remain1 // 10
a += remain2 % 5 + remain2 // 5
print(a)


n = int(input())
bills = [100, 20, 10, 5, 1]
amt = 0

def mappings(x):
	global n, amt
	amt += n // x
	n = n % x
list(map(mappings, bills))
print(amt)


dollars = int(input())
kup_1 = 0
kup_2 = 0
kup_3 = 0
kup_4 = 0
kup_5 = 0
if 1 <= dollars <= 10 ** 9:
	if dollars // 100 != 0:
		kup_1 = dollars // 100
		dollars -= kup_1 * 100
	if dollars // 20 != 0:
		kup_2 = dollars // 20
		dollars -= kup_2 * 20
	if dollars // 10 != 0:
		kup_3 = dollars // 10
		dollars -= kup_3 * 10
	if dollars // 5 != 0:
		kup_4 = dollars // 5
		dollars -= kup_4 * 5
	if dollars < 5:
		kup_5 = dollars
kup_res = kup_1 + kup_2 + kup_3 + kup_4 + kup_5
print(kup_res)


vals = [1, 5, 10, 20, 100]

def main():
	s = int(input())
	cur = 4
	c = 0
	while s != 0:
		d = s // vals[cur]
		if d == 0:
			cur -= 1
			continue
		s = s - d * vals[cur]
		c += d
	print(c)
main()


dollars = int(input())
den = 0
if dollars // 100 > 0:
	n = dollars // 100
	den += n
	dollars = dollars - 100 * n
if dollars // 20 > 0:
	n = dollars // 20
	den += n
	dollars = dollars - 20 * n
if dollars // 10 > 0:
	n = dollars // 10
	den += n
	dollars = dollars - 10
if dollars // 5 > 0:
	n = dollars // 5
	den += dollars // 5
	dollars = dollars - 5
if dollars // 1 > 0:
	n = dollars // 1
	den += dollars // 1
	dollars = dollars - 1
print(den)


N = int(input())
bills = [100, 20, 10, 5, 1]
total = 0
for i in range(5):
	count = N // bills[i]
	N -= count * bills[i]
	total += count
print(total)


n = int(input())
count = 0
if n > 99:
	count += n // 100
	n = n - n // 100 * 100
if n > 19:
	count += n // 20
	n = n - n // 20 * 20
if n > 9:
	count += n // 10
	n = n - n // 10 * 10
if n > 4:
	count += n // 5
	n = n - n // 5 * 5
count += n
print(count)


n = int(input())

def min_notes(n):
	count = 0
	while n != 0:
		if n >= 100:
			while n >= 100:
				count += 1
				n -= 100
		elif n >= 20:
			while n >= 20:
				count += 1
				n -= 20
		elif n >= 10:
			while n >= 10:
				count += 1
				n -= 10
		elif n >= 5:
			while n >= 5:
				count += 1
				n -= 5
		elif n < 5:
			while n != 0:
				count += 1
				n -= 1
	print(count)
min_notes(n)


n = int(input())
s = 0
while n >= 100:
	s += int(n / 100)
	n -= 100 * int(n / 100)
while n >= 20:
	s += int(n / 20)
	n -= 20 * int(n / 20)
while n >= 10:
	s += int(n / 10)
	n -= 10 * int(n / 10)
while n >= 5:
	s += int(n / 5)
	n -= 5 * int(n / 5)
s += n
print(s)


bills = [100, 20, 10, 5, 1]
number_bills = 0
n = int(input())
for i in bills:
	if n == 0:
		print(number_bills)
		break
	elif n >= i:
		number_bills += n // i
		n -= n // i * i
else:
	print(number_bills)


n = int(input())
m = [100, 20, 10, 5, 1]
d = 0
for k in range(5):
	d = d + n // m[k]
	n = n % m[k]
print(d)


n = int(input())
k1 = n // 100
n = n % 100
k2 = n // 20
n = n % 20
k3 = n // 10
n = n % 10
k4 = n // 5
n = n % 5
print(k1 + k2 + k3 + k4 + n)


def get_dollar_bills(n):
	dollar_bills = []
	withdraw_quantities = [100, 20, 10, 5, 1]
	for quantity in withdraw_quantities:
		while n >= quantity:
			dollar_bill = int(n / quantity)
			dollar_bills.append(dollar_bill)
			n = n - quantity * dollar_bill
	return sum(dollar_bills)

def main():
	n = int(input())
	bills = get_dollar_bills(n)
	print(bills)
main()


import sys
money = int(input())
ans = 0
while money != 0:
	if money >= 100:
		times = money // 100
		money -= times * 100
	elif money >= 20:
		times = money // 20
		money -= times * 20
	elif money >= 10:
		times = money // 10
		money -= times * 10
	elif money >= 5:
		times = money // 5
		money -= times * 5
	else:
		times = money // 1
		money -= times * 1
	ans += times
print(ans)
sys.exit()


n = int(input())
count = 0
l = [1, 5, 10, 20, 100]
for k in range(4, -1, -1):
	count += n // l[k]
	n %= l[k]
print(count)


a = int(input())
b = [100, 20, 10, 5, 1]
c = 0
for i in b:
	if a / i == 0:
		continue
	if a / i != 0:
		c = c + int(a / i)
		a = a % i
print(c)


n = int(input())
den = [100, 20, 10, 5]
bill = 0
for i in den:
	bill += n // i
	n = n - n // i * i
bill += n
print(bill)


while True:
	try:
		n = int(input())
		sum = 0
		sum += int(n / 100)
		n -= int(n / 100) * 100
		sum += int(n / 20)
		n -= int(n / 20) * 20
		sum += int(n / 10)
		n -= int(n / 10) * 10
		sum += int(n / 5)
		n -= int(n / 5) * 5
		sum += n
		print(sum)
	except:
		break


n = int(input())
h = int(n / 100)
n -= h * 100
t = int(n / 20)
n -= t * 20
ten = int(n / 10)
n -= ten * 10
f = int(n / 5)
n -= f * 5
print(h + t + ten + f + n)


import sys

def fastio():
	from io import StringIO
	from atexit import register
	global input
	sys.stdin = StringIO(sys.stdin.read())
	input = lambda : sys.stdin.readline().rstrip('\r\n')
	sys.stdout = StringIO()
	register(lambda : sys.__stdout__.write(sys.stdout.getvalue()))
fastio()

def debug(*var):
	print(*var, file=sys.stderr)
INF = 10 ** 20
MOD = 10 ** 9 + 7
I = lambda : list(map(int, input().split()))
from math import gcd
from collections import defaultdict as dd, Counter
from bisect import bisect_left as bl, bisect_right as br
(n,) = I()
d = [100, 20, 10, 5, 1]
ans = 0
for i in d:
	ans += n // i
	n -= n // i * i
print(ans)


import sys
n = int(input())
result = n // 100 + n % 100 // 20 + n % 20 // 10 + n % 10 // 5 + n % 5
print(result)


bill = int(input())
balance = 0
notes = [100, 20, 10, 5, 1]
for i in notes:
	balance += bill // i
	bill = bill % i
print(balance)


x = int(input())
f = 0
notes = [100, 20, 10, 5, 1]
for i in notes:
	y = x // i
	if y > 0:
		x = x % i
		f += y
print(int(f))


x = int(input())
L = [100, 20, 10, 5, 1]
a = 0
for i in L:
	q = x // i
	a += q
	x -= q * i
	if x == 0:
		break
print(a)


(n, v) = (int(input()), 0)
for b in (100, 20, 10, 5, 1):
	(n, v) = (n % b, v + n // b)
print(v)


n = int(input())
number_of_bills = 0
if n >= 100:
	number_of_bills += n // 100
	n = n % 100
if n >= 20:
	number_of_bills += n // 20
	n = n % 20
if n >= 10:
	number_of_bills += n // 10
	n = n % 10
if n >= 5:
	number_of_bills += n // 5
	n = n % 5
number_of_bills += n
print(number_of_bills)


x = int(input())
y = x // 100
z = x - y * 100
c = z // 20
v = z % 20
b = v // 10
n = v % 10
m = n // 5
l = n % 5
print(y + c + b + m + l)


x = int(input())
w = 0
arr = [100, 20, 10, 5]
for i in arr:
	w += x // i
	x = x % i
print(x + w)


n = input()
n = int(n)
aux = 0
aux = n // 100
n = n % 100
aux = aux + n // 20
n = n % 20
aux = aux + n // 10
n = n % 10
aux = aux + n // 5
n = n % 5
aux = aux + n // 1
n = n % 1
print(aux)


n = int(input())
notes = 0
while n != 0:
	if n >= 100:
		div = n // 100
		n = n - div * 100
		notes += div
	elif n >= 20:
		div = n // 20
		n = n - div * 20
		notes += div
	elif n >= 10:
		div = n // 10
		n = n - div * 10
		notes += div
	elif n >= 5:
		div = n // 5
		n = n - div * 5
		notes += div
	elif n >= 1:
		div = n // 1
		n = n - div * 1
		notes += div
print(notes)


def ones(one):
	if one > 4:
		return 1 + (one - 5)
	else:
		return one

def tens(n):
	tens = n // 10
	if tens % 2 == 0:
		return tens // 2 + ones(n % 10)
	elif tens > 2:
		return tens // 2 + 1 + ones(n % 10)
	else:
		return 1 + ones(n % 10)

def solve(n):
	le = str(n)
	l1 = len(le)
	if l1 > 2:
		if le[-2] == '0':
			return n // 100 + ones(int(le[-1]))
		else:
			return n // 100 + tens(int(le[-2:]))
	elif l1 > 1:
		return tens(n)
	else:
		return ones(n)
n = int(input())
result = solve(n)
print(result)


def solve(n):
	a = [100, 20, 10, 5, 1]
	shetchik = 0
	ff = n // 100
	c = n % 100
	ff = ff + c // 20
	c = c % 20
	ff = ff + c // 10
	c = c % 10
	ff = ff + c // 5
	c = c % 5
	ff = ff + c // 1
	c = c % 1
	return ff
t = 1
t = int(t)
shetchikshetchikov = 0
while shetchikshetchikov < t:
	n = input()
	n = int(n)
	print(solve(n))
	shetchikshetchikov = shetchikshetchikov + 1


n = int(input())
l = [100, 20, 10, 5, 1]
c = 0
for z in range(len(l)):
	if n >= l[z]:
		q = n // l[z]
		c = c + q
		n = n % l[z]
print(c)


a = [100, 20, 10, 5, 1]
n = int(input())
i = 0
ct = 0
while n > 0:
	ct += n // a[i]
	n = n % a[i]
	i += 1
print(ct)


n = int(input())
coins = [100, 20, 10, 5, 1]
count = 0
for c in coins:
	while n >= c:
		n -= c
		count += 1
print(count)


n = int(input())
no = 0
no += int(n / 100)
n %= 100
no += int(n / 20)
n %= 20
no += int(n / 10)
n %= 10
no += int(n / 5)
n %= 5
no += n
print(no)


n = int(input())
s = 0
tmp = int(n / 100)
n -= tmp * 100
s += tmp
tmp = int(n / 20)
n -= tmp * 20
s += tmp
tmp = int(n / 10)
n -= tmp * 10
s += tmp
tmp = int(n / 5)
n -= tmp * 5
s += tmp
s += n
print(int(s))


amount = int(input())
hundred = 0
twenty = 0
ten = 0
five = 0
one = 0
if amount >= 100:
	hundred += int(amount / 100)
	amount -= int(amount / 100) * 100
if amount >= 20:
	twenty += int(amount / 20)
	amount -= int(amount / 20) * 20
if amount >= 10:
	ten += int(amount / 10)
	amount -= int(amount / 10) * 10
if amount >= 5:
	five += int(amount / 5)
	amount -= int(amount / 5) * 5
if amount >= 1:
	one += int(amount / 1)
	amount -= int(amount / 1) * 1
print(hundred + twenty + ten + five + one)


n = int(input())
count = 0
temp = 0
temp = int(n / 100)
n = n % 100
count += temp
temp = int(n / 20)
n = n % 20
count += temp
temp = int(n / 10)
n = n % 10
count += temp
temp = int(n / 5)
n = n % 5
count += temp
temp = int(n / 1)
n = n % 1
count += temp
print(count)


n = int(input())
(x1, x2, x3, x4, x5) = (0, 0, 0, 0, 0)
if n >= 100:
	x1 = n // 100
	n = n % 100
if n >= 20:
	x2 = n // 20
	n = n % 20
if n >= 10:
	x3 = n // 10
	n = n % 10
if n >= 5:
	x4 = n // 5
	n = n % 5
print(x1 + x2 + x3 + x4 + n)


import sys

def main():
	f = sys.stdin
	n = int(f.readline())
	lottery = [100, 20, 10, 5, 1]
	res = 0
	for l in lottery:
		res += n // l
		n = n % l
	print(res)
main()


def withMoney(money, bill):
	print(str(money) + '--' + str(bill))
	if money >= bill:
		cambio = money % bill
		print(str(b) + '>>' + str(cambio))
		return int(b)
bills = [100, 20, 10, 5, 1]
moneyIn = input()
money = int(moneyIn)
if int(money) > 0:
	i = 0
	total = 0
	numB = 0
	cambio = money
	for bill in bills:
		if int(money) >= bill:
			numB = int(money / bill)
			money = int(money) % bill
			total = total + int(numB)
			if money == 0:
				break
	print(total)
elif int(money) == 0 or money > 1000000000:
	print(0)


n = int(input())
l = [100, 20, 10, 5, 1]
bills = 0
for i in l:
	rem = n % i
	if n // i != 0:
		qu = n // i
		n = rem
		bills = bills + qu
print(bills)


def lottery():
	n = int(input())
	x = 0
	if n >= 100:
		a = n - n % 100
		x += a / 100
		a = 0
		n = n % 100
	if n >= 20:
		a = n - n % 20
		x += a / 20
		a = 0
		n = n % 20
	if n >= 10:
		a = n - n % 10
		x += a / 10
		a = 0
		n = n % 10
	if n >= 5:
		a = n - n % 5
		x += a / 5
		a = 0
		n = n % 5
	if n >= 1:
		a = n - n % 1
		x += a / 1
		a = 0
		n = n % 1
	print(int(x))
lottery()


coins = [1, 5, 10, 20, 100]
cash = int(input())
coinsNum = 0
for i in range(len(coins) - 1, -1, -1):
	coinsNum += cash // coins[i]
	cash = cash % coins[i]
	if cash == 0:
		break
print(coinsNum)


n = int(input())
number_of_100 = 0
number_of_20 = 0
number_of_10 = 0
number_of_5 = 0
number_of_1 = 0
number_of_100 = n // 100
n -= number_of_100 * 100
number_of_20 = n // 20
n -= number_of_20 * 20
number_of_10 = n // 10
n -= number_of_10 * 10
number_of_5 = n // 5
n -= number_of_5 * 5
number_of_1 = n
amount_of_bills = number_of_1 + number_of_5 + number_of_10 + number_of_20 + number_of_100
print(amount_of_bills)


L = [1, 5, 10, 20, 100]
T = int(input())
count = 0
while T != 0:
	maxs = 10 ** 9
	val = 0
	for i in L:
		tmp = T // i
		valp = T % i
		if tmp < maxs and tmp != 0:
			maxs = tmp
			val = valp
	count += maxs
	T = val
print(count)


def solve(n):
	count = 0
	a = n // 100
	minus = n - 100 * a
	b = minus // 20
	minus -= 20 * b
	c = minus // 10
	minus -= 10 * c
	d = minus // 5
	minus -= 5 * d
	e = minus // 1
	return a + b + c + d + e
n = int(input())
print(solve(n))


n = int(input())
res1 = n // 100
n -= res1 * 100
res2 = n // 20
n -= res2 * 20
res3 = n // 10
n -= res3 * 10
res4 = n // 5
n -= res4 * 5
print(res1 + res2 + res3 + res4 + n)


R = lambda : map(int, input().split())
n = int(input())
s = 0
for t in (100, 20, 10, 5):
	s += n // t
	n = n % t
print(s + n)


n = int(input())
s = 0
b = [100, 20, 10, 5, 1]
for e in b:
	s += n // e
	n %= e
print(s)


n = int(input())
l = [100, 20, 10, 5, 1]
c = 0
i = 0
while n != 0:
	s = n // l[i]
	if s >= 1:
		n -= l[i] * s
		c += s
	else:
		i += 1
print(c)


dollars = int(input())
particular_case = [pow(10, 3), pow(10, 4), pow(10, 5), pow(10, 6), pow(10, 7), pow(10, 8), pow(10, 9)]
bills = 0
if dollars >= 1 and dollars <= pow(10, 9):
	while dollars > 0:
		if len(str(dollars)) > 1 and str(dollars)[-1] == '0' and (str(dollars)[-2] == '0'):
			if dollars % 100 == 0:
				dollars = int(dollars / 100)
				bills += dollars
				dollars = 0
			else:
				dollars -= 100
				bills += 1
		if len(str(dollars)) > 0 and str(dollars)[-1] != '0' and (str(dollars)[-1] == '5'):
			dollars -= 5
			bills += 1
		if dollars % 20 == 0:
			while dollars % 20 == 0 and len(str(dollars)) > 1 and (not (str(dollars)[-1] == '0' and str(dollars)[-2] == '0')):
				dollars -= 20
				bills += 1
		if len(str(dollars)) > 1 and dollars % 10 == 0 and (not (str(dollars)[-1] == '0' and str(dollars)[-2] == '0')):
			dollars -= 10
			bills += 1
		if len(str(dollars)) > 0 and str(dollars)[-1] != '0' and (str(dollars)[-1] != '5'):
			dollars -= 1
			bills += 1
print(bills)


import sys
import collections

def readArray(type=int):
	line = input()
	return [type(x) for x in line.split()]

def getFreq(array):
	pass

def solve():
	bills = [1, 5, 10, 20, 100]
	n = int(input())
	cc = 0
	for x in reversed(bills):
		cc += n // x
		n = n % x
	print(cc)
solve()


n = int(input())
cash = [1, 5, 10, 20, 100]
count = 0
while n > 0:
	if n - cash[-1] < 0:
		cash.pop()
	else:
		div = n // cash[-1]
		count += div
		n -= div * cash[-1]
print(count)


x = int(input())
b = [100, 20, 10, 5, 1]
c = 0
while x > 0:
	b = list(filter(lambda a: a <= x, b))
	c += x // b[0]
	x %= b[0]
print(c)


import math
a = int(input())
n = 0
for e in [100, 20, 10, 5, 1]:
	n += math.floor(a / e)
	a -= math.floor(a / e) * e
print(n)


n = int(input())
op = [100, 20, 10, 5, 1]
l = []
for item in op:
	p = n // item
	l.append(p)
	n -= item * p
print(sum(l))


def pool(money, weight, i=0):
	counts = money // weight[i]
	money -= counts * weight[i]
	if money == 0:
		return counts
	else:
		i += 1
		return counts + pool(money, weight, i)
money = int(input())
weight = (100, 20, 10, 5, 1)
print(pool(money, weight))


def send(x):
	print(x)
	return x

def check(x):
	if x >= 100:
		return divmod(x, 100)
	elif x >= 20:
		return divmod(x, 20)
	elif x >= 10:
		return divmod(x, 10)
	elif x >= 5:
		return divmod(x, 5)
	else:
		return divmod(x, 1)
money = int(input(''))
number = 0
while money > 0:
	number = number + check(money)[0]
	money = check(money)[1]
send(number)


num = int(input())
res = num // 100 + num % 100 // 20 + num % 20 // 10 + num % 10 // 5 + num % 5 // 1 + num % 1
print(res)


n = int(input())
cnt = 0
m = n % 100
cnt += n // 100
n = m
cnt += n // 20
n = n % 20
cnt += n // 10
n = n % 10
cnt += n // 5
n = n % 5
cnt += n // 1
print(cnt)


n = int(input())
bills = [100, 20, 10, 5, 1]
ans = 0
bill = 0
while n:
	cur_bill = bills[bill]
	quotient = n // cur_bill
	if quotient == 0:
		bill += 1
	else:
		ans += quotient
		n %= cur_bill
print(ans)


n = int(input())
a = [1, 5, 10, 20, 100]
a.reverse()
dp = []
for i in range(len(a)):
	dp.append(0)
for i in range(len(a)):
	dp[i] = n // a[i]
	n = n % a[i]
print(sum(dp))


denomination = [100, 20, 10, 5, 1]
n = int(input())
used_denomination = 0
for i in denomination:
	if i <= n:
		used_denomination += n // i
		n = n % i
	if n == 0:
		break
print(used_denomination)


def operation(number1, number2):
	t = int(number1) / int(number2)
	return int(t)
bills = [100, 20, 10, 5, 1]
x = int(input())
index = 0
number = 0
while index < bills.__len__():
	number += operation(x, bills[index])
	x = x % bills[index]
	index += 1
print(number)


q = int(input())
s = q // 100
q = q % 100
s = s + q // 20
q = q % 20
s = s + q // 10
q = q % 10
s = s + q // 5
q = q % 5
s = s + q
print(s)


money = int(input())
money_bills = [100, 20, 10, 5, 1]
n_of_bills = 0
for element in money_bills:
	n_of_bills += money // element
	money = money % element
print(n_of_bills)


n = int(input())
count = 0
bills = [1, 5, 10, 20, 100]
for i in range(4, -1, -1):
	if n > 0:
		c = n // bills[i]
		n -= c * bills[i]
		count += c
print(count)


n = int(input())
c1 = n // 100
r = n % 100
c2 = r // 20
r %= 20
c3 = r // 10
r %= 10
c4 = r // 5
r %= 5
c5 = r
print(int(c1 + c2 + c3 + c4 + c5))


MAXN = 105
coins = [1, 5, 10, 20, 100]
n = int(input())
dp = [MAXN] * MAXN
dp[0] = 0
for i in range(1, MAXN):
	for c in coins:
		if c > i:
			break
		dp[i] = min(dp[i], 1 + dp[i - c])
print(n // 100 + dp[n % 100])


total_ammount = int(input())
num_bills = 0
for den in [100, 20, 10, 5, 1]:
	num_bills_den = total_ammount // den
	num_bills += num_bills_den
	total_ammount -= num_bills_den * den
print(num_bills)


n = int(input())
money = 0
if n // 100 > 0:
	money += n // 100
	n %= 100
if n // 20 > 0:
	money += n // 20
	n %= 20
if n // 10 > 0:
	money += n // 10
	n %= 10
if n // 5 > 0:
	money += n // 5
	n %= 5
money += n
print(money)


p = int(input())
k = 0
if p / 100 > 0:
	k += int(p / 100)
	p = p % 100
if p / 20 > 0:
	k += int(p / 20)
	p = p % 20
if p / 10 > 0:
	k += int(p / 10)
	p = p % 10
if p / 5 > 0:
	k += int(p / 5)
	p = p % 5
if p / 1 > 0:
	k += int(p / 1)
	p = p % 1
print(k)


n = int(input())
notes = (100, 20, 10, 5, 1)
result = 0
for i in notes:
	result += n // i
	n %= i
print(result)


n = int(input())
bills = [100, 20, 10, 5, 1]
min_number = 0
for bill in bills:
	anzahl = int(n / bill)
	n -= bill * anzahl
	min_number += anzahl
	if n == 0:
		break
print(min_number)


x = int(input())
ans = 0
ans += x // 100
x = x % 100
ans += x // 20
x = x % 20
ans += x // 10
x = x % 10
ans += x // 5
x = x % 5
ans += x / 1
x = x % 1
print(int(ans))


l = [100, 20, 10, 5, 1]
n = int(input())
p = 0
for i in range(len(l)):
	p += n // l[i]
	o = n % l[i]
	n = o
print(p)


x = int(input())
a1 = x // 100
b1 = x - 100 * a1
a2 = b1 // 20
b2 = b1 - 20 * a2
a3 = b2 // 10
b3 = b2 - 10 * a3
a4 = b3 // 5
b4 = b3 - 5 * a4
print(a1 + a2 + a3 + a4 + b4)


n = int(input())
b = [100, 20, 10, 5, 1]
c = 0
for i in b:
	c += n // i
	n %= i
	if not n:
		break
print(c)


g = [1, 5, 10, 20, 100]
n = int(input())
x = 0
for i in g[::-1]:
	if n >= i:
		k = n // i
		x += k
		n -= k * i
print(x)


money = int(input())
money_nominal = [1, 5, 10, 20, 100]
number_of_notes = 0
while money != 0:
	for note in money_nominal:
		if money // note != 0:
			needed_note = note
	number_of_notes += money // needed_note
	money %= needed_note
print(number_of_notes)


n = int(input())
bills = 0
types = [100, 20, 10, 5, 1]
for t in types:
	bills = bills + int(n / t)
	n = n - int(n / t) * t
	if n % t == 0:
		break
print(bills)


def func(n: int, l: list):
	if len(l) == 0:
		return 0
	t = l[0]
	l.remove(l[0])
	return n // t + func(n - n // t * t, l)
n = int(input())
print(func(n, [100, 20, 10, 5, 1]))


money = int(input())
change = [money, 0, 0, 0, 0]
for (value, currency) in enumerate((100, 20, 10, 5)):
	(change[value], change[value + 1]) = divmod(change[value], currency)
print(sum(change))


n = int(input())
billetes = [1, 5, 10, 20, 100]
numsb = 0
for billete in billetes[::-1]:
	tmp = n // billete
	numsb += tmp
	n -= billete * tmp
print(numsb)


from sys import stdin, stdout, setrecursionlimit
import heapq
from math import gcd, ceil, sqrt
from collections import Counter, deque
from bisect import bisect_left, bisect_right
ii1 = lambda : int(stdin.readline().strip())
is1 = lambda : stdin.readline().strip()
iia = lambda : list(map(int, stdin.readline().strip().split()))
isa = lambda : stdin.readline().strip().split()
setrecursionlimit(100000)
mod = 1000000007
arr = [100, 20, 10, 5, 1]
n = ii1()
res = 0
while n > 0:
	cur = arr.pop(0)
	res += n // cur
	n %= cur
print(res)


num = int(input())
notes = [100, 20, 10, 5, 1]
count = 0
for note in notes:
	if num > 0:
		count += num // note
		num = num % note
	else:
		break
print(count)


num = int(input())
notes = 0
while num > 0:
	if num >= 100:
		val = num // 100
		num -= val * 100
		notes += val
		continue
	if num >= 20:
		val = num // 20
		num -= val * 20
		notes += val
		continue
	if num >= 10:
		val = num // 10
		num -= val * 10
		notes += val
		continue
	if num >= 5:
		val = num // 5
		num -= val * 5
		notes += val
		continue
	if num >= 1:
		val = num // 1
		num -= val * 1
		notes += val
		continue
print(notes)


import sys
from itertools import permutations
input = sys.stdin.readline
n = int(input())
l = [1, 5, 10, 20, 100]
ans = 0
for i in range(4, -1, -1):
	ans += n // l[i]
	n %= l[i]
print(ans)


n = int(input())
k1 = n // 100
n1 = n % 100
k2 = n1 // 20
n2 = n1 % 20
k3 = n2 // 10
n3 = n2 % 10
k4 = n3 // 5
n4 = n3 % 5
k5 = n4 // 1
n5 = n4 % 1
p = k1 + k2 + k3 + k4 + k5
print(p)


m = int(input())
a = 0
if m >= 100:
	a = m // 100
	m = m % 100
if m >= 20:
	a = a + m // 20
	m = m % 20
if m >= 10:
	a = a + m // 10
	m = m % 10
if m >= 5:
	a = a + m // 5
	m = m % 5
if m >= 1:
	a = a + m // 1
print(a)


a = int(input())
i = 0
ans = 0
ans += int(a / 100)
i = a % 100
ans += int(i / 20)
i = i % 20
ans += int(i / 10)
i = i % 10
ans += int(i / 5)
i = i % 5
ans += int(i / 1)
print(ans)


import sys
import math
_inputs = [x for x in '125\n'.split('\n') if bool(x)]
if '--debug' not in sys.argv:
	_inputs = [input() for _ in range(len(_inputs))]
n = int(_inputs[0])
nominals = [100, 20, 10, 5, 1]
currentNominal = 0
result = 0
while True:
	result += n // nominals[currentNominal]
	n = n % nominals[currentNominal]
	if n == 0:
		break
	currentNominal += 1
print(result)


n = int(input())
ini = 0
while n > 0:
	if n >= 100:
		a = n // 100
		n = n % 100
		ini += a
	elif n >= 20:
		a = n // 20
		n = n % 20
		ini += a
	elif n >= 10:
		a = n // 10
		n = n % 10
		ini += a
	elif n >= 5:
		a = n // 5
		n = n % 5
		ini += a
	else:
		ini += n
		n = 0
print(ini)


def main():
	n = int(input())
	dollars = [1, 5, 10, 20, 100]
	output = 0
	while n != 0:
		bill = [i for i in dollars if i <= n][-1]
		output += n // bill
		n = n % bill
	print(output)
main()


x = int(input())
li = [100, 20, 10, 5, 1]
v = 0
for i in range(5):
	if x % li[i] >= 0 and x % li[i] != x:
		v += x // li[i]
		x = x - x // li[i] * li[i]
print(v)


import math
balance = int(input())
count = 0
bills = [100, 20, 10, 5, 1]
check = balance % 10
ans = balance // 100
if check == 0 and ans > 0:
	print(math.ceil(balance / 100))
else:
	for i in bills:
		while balance >= i:
			balance -= i
			count += 1
		if balance < i:
			continue
		elif balance == 0:
			break
	print(count)


n = int(input())
num = 0
num += n // 100
n = n % 100
num += n // 20
n = n % 20
num += n // 10
n = n % 10
num += n // 5
n = n % 5
num += n // 1
n = n % 1
print(num)


n = int(input())
(q, r, total) = (0, 0, 0)
for i in [100, 20, 10, 5, 1]:
	if n >= i:
		total += int(n / i)
		n %= i
print(total)


import math
n = int(input())
bills = 0
while n > 0:
	if n / 100 >= 1:
		bills += math.floor(n / 100)
		n = n % 100
	elif n / 20 >= 1:
		bills += math.floor(n / 20)
		n = n % 20
	elif n / 10 >= 1:
		bills += math.floor(n / 10)
		n = n % 10
	elif n / 5 >= 1:
		bills += math.floor(n / 5)
		n = n % 5
	else:
		bills += n
		n = 0
print(bills)


def hitTheLottery():
	n = int(input())
	count = 0
	count += int(n / 100)
	n = n % 100
	count += int(n / 20)
	n = n % 20
	count += int(n / 10)
	n = n % 10
	count += int(n / 5)
	n = n % 5
	count += int(n / 1)
	n = n % 1
	print(count)
hitTheLottery()


m = int(input())
list1 = [100, 20, 10, 5, 1]
count = 0
for i in list1:
	if m // i >= 1:
		count += m // i
		m = m % i
print(count)


money = int(input())
answer = 0
while money > 0:
	if money >= 100:
		money -= 100
		answer += 1
	elif money >= 20:
		money -= 20
		answer += 1
	elif money >= 10:
		money -= 10
		answer += 1
	elif money >= 5:
		money -= 5
		answer += 1
	else:
		money -= 1
		answer += 1
print(answer)


n = int(input())
b = 0
lis = [100, 20, 10, 5, 1]
for i in lis:
	if n // i > 0 and n != 0:
		b = b + n // i
		c = n // i
		n = n - i * c
print(b)


n = int(input())
bills = 0
pos = [100, 20, 10, 5, 1]
while n > 0:
	for e in pos:
		k = n // e
		n = n - k * e
		bills += k
print(bills)


n = int(input())
cnt = 0
buf = [100, 20, 10, 5, 1]
for i in buf:
	cnt += n // i
	n %= i if n // i > 0 else n + 1
print(cnt)


n = int(input())
ls = [100, 20, 10, 5, 1]
m = 0
for i in ls:
	if n != 0:
		m += n // i
		n = n % i
	else:
		break
print(m)


def solve(n):
	arr = [100, 20, 10, 5, 1]
	ans = 0
	while n > 0:
		for i in range(len(arr)):
			if n // arr[i] >= 1:
				ans += n // arr[i]
				n = n % arr[i]
				break
	print(ans)

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


n = int(input())
total = n
bill = 0
while total != 0:
	if int(total / 100) != 0:
		bill += int(total / 100)
		total -= int(total / 100) * 100
	elif int(total / 20) != 0:
		bill += int(total / 20)
		total -= int(total / 20) * 20
	elif int(total / 10) != 0:
		bill += int(total / 10)
		total -= int(total / 10) * 10
	elif int(total / 5) != 0:
		bill += int(total / 5)
		total -= int(total / 5) * 5
	elif int(total / 1) != 0:
		bill += int(total / 1)
		total -= int(total / 1) * 1
print(bill)


import time
import collections

class Time_test:

	def __enter__(self):
		self.enter_time = time.time()

	def __exit__(self, exc_type, exc_val, exc_tb):
		print('Command was executed in', time.time() - self.enter_time)
n = int(input())
counter = n // 100
n %= 100
counter += n // 20
n %= 20
counter += n // 10
n %= 10
counter += n // 5
n %= 5
print(counter + n)


a = int(input())
count = 0
while a > 0:
	q = a // 100
	f = a % 100
	g = f // 20
	g1 = f % 20
	c = g1 // 10
	c1 = g1 % 10
	r = c1 // 5
	r1 = c1 % 5
	y = r1 // 1
	print(q + g + c + r + y)
	break


money = int(input())
num_bills = 0
hundred = money // 100
twenty = (money - hundred * 100) // 20
ten = (money - hundred * 100 - twenty * 20) // 10
five = (money - hundred * 100 - twenty * 20 - ten * 10) // 5
single = money - hundred * 100 - twenty * 20 - ten * 10 - five * 5
num_bills = hundred + twenty + ten + five + single
print(num_bills)


import math
n = int(input())
c = 0
m = -1
while True:
	if n >= 100:
		m = int(n / 100)
		n = int(n % 100)
		c = c + m
	elif n >= 20:
		m = int(n / 20)
		n = int(n % 20)
		c = c + m
	elif n >= 10:
		m = int(n / 10)
		n = int(n % 10)
		c = c + m
	elif n >= 5:
		m = int(n / 5)
		n = int(n % 5)
		c = c + m
	elif n >= 1:
		c = c + n
		break
	if n == 0:
		break
print(c)


n = int(input())
ans = 0
for i in [100, 20, 10, 5]:
	while n >= i:
		ans += n // i
		n = n - n // i * i
print(ans + n)


n = int(input())
c = 0
t = n
f = 0
if n >= 100:
	c += t // 100
	t = t % 100
	if t >= 20:
		x = t // 10
		c += x // 2
		t = t - 20 * (x // 2)
	if t >= 10 and t < 20:
		c += 1
		t -= 10
	if t < 10 and t >= 5:
		c += 1
		t -= 5
	if t < 5 and t >= 1:
		f = 1
		c += t
if t >= 20:
	x = t // 10
	c += x // 2
	t = t - 20 * (x // 2)
if t >= 10 and t < 20:
	c += 1
	t -= 10
if t < 10 and t >= 5:
	c += 1
	t -= 5
if t < 5 and t >= 1 and (f != 1):
	c += t
	t = 0
print(c)


num = str(input(''))
a = int(num)
b1 = int(a / 100)
b2 = int(a % 100)
c1 = int(b2 / 20)
c2 = int(b2 % 20)
d1 = int(c2 / 10)
d2 = int(c2 % 10)
e1 = int(d2 / 5)
e2 = int(d2 % 5)
result = int(b1 + c1 + d1 + e1 + e2)
print(result)


def FindAmountOfBills(nominals, total):
	if len(nominals) == 0:
		return 0
	else:
		return total // nominals[-1] + FindAmountOfBills(nominals[:-1], total - total // nominals[-1] * nominals[-1])
n = int(input())
print(FindAmountOfBills([1, 5, 10, 20, 100], n))


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

def print(x):
	return sys.stdout.write(str(x) + '\n')

def main():
	n = int(input())
	count = 0
	arr = [1, 5, 10, 20, 100]
	if n >= 100:
		count += n // 100
		n %= 100
	if n >= 20:
		count += n // 20
		n %= 20
	if n >= 10:
		count += n // 10
		n %= 10
	if n >= 5:
		count += n // 5
		n %= 5
	if n >= 1:
		count += n
	print(count)
main()


money = int(input())
count = 0
test = [100, 20, 10, 5, 1]
for counter in range(len(test)):
	a = money // test[counter]
	if a > 0:
		count += a
		money -= a * test[counter]
print(count)


money = int(input())
denoms = [100, 20, 10, 5, 1]
bills = 0
for denom in denoms:
	if money >= denom:
		bills += money // denom
		money = money % denom
print(bills)


n = int(input())
lt = [1, 5, 10, 20, 100]
coins = 0
for i in lt[::-1]:
	if n == 0:
		break
	if n >= i:
		coins += int(n / i)
		n = n % i
print(coins)


x = int(input())
print(int(x // 100 + x % 100 // 20 + x % 20 // 10 + x % 10 // 5 + x % 5 / 1))


num = int(input())
jumlah = 0
if num // 100:
	jumlah += num // 100
	num = num % 100
if num // 20:
	jumlah += num // 20
	num = num % 20
if num // 10:
	jumlah += num // 10
	num = num % 10
if num // 5:
	jumlah += num // 5
	num = num % 5
if num // 1:
	jumlah += num // 1
	num = num % 1
print(jumlah)


from sys import stdin, stdout
input = stdin.readline()

def main():
	n = int(input)
	denominations = [100, 20, 10, 5, 1]
	count = 0
	for denom in denominations:
		count = count + int(n / denom)
		n = int(n % denom)
		if n == 0:
			break
	print(count)
main()


import math
n = int(input())
bills = [100, 20, 10, 5, 1]
ind = 0
num_bills = 0
while n > 0:
	if n >= bills[ind]:
		tmp = math.floor(n / bills[ind])
		num_bills += tmp
		n = n - tmp * bills[ind]
	ind += 1
print(num_bills)


def f(n):
	hundredBill = int(n / 100)
	reste = n % 100
	twentyBill = int(reste / 20)
	reste = reste % 20
	tenBill = int(reste / 10)
	reste = reste % 10
	fiveBill = int(reste / 5)
	reste = reste % 5
	oneBill = reste
	return hundredBill + twentyBill + tenBill + fiveBill + oneBill
n = int(input())
print(f(n))


n = int(input())
a = int(n / 100)
a1 = int(n % 100)
b = int(a1 / 20)
b1 = int(a1 % 20)
c = int(b1 / 10)
c1 = int(b1 % 10)
e = int(c1 / 5)
e1 = int(c1 % 5)
f = a + b + c + e + e1
print(f)


n = int(input())
c = int(n / 100)
s = n - int(n / 100) * 100
c = c + int(s / 20)
r = s - int(s / 20) * 20
c = c + int(r / 10)
p = r - int(r / 10) * 10
c = c + int(p / 5)
q = p - int(p / 5) * 5
c = c + q
print(c)


n = int(input())
p = 0
while n != 0:
	if n >= 100:
		q = n / 100
		q = int(q)
		n = n - 100 * q
		p = p + 1 * q
	elif n >= 20:
		n = n - 20
		p = p + 1
	elif n >= 10:
		n = n - 10
		p = p + 1
	elif n >= 5:
		n = n - 5
		p = p + 1
	elif n >= 1:
		n = n - 1
		p = p + 1
print(p)


deno = [1, 5, 10, 20, 100]
a = int(input())
deno.sort(reverse=True)
c = 0
for i in deno:
	c = c + a // i
	a = a - i * (a // i)
print(c)


class problema_D:

	def __init__(self):
		self.resposta = ''
		self.quantidade = 0

	def leitura_dados(self):
		self.quantidade = int(input())

	def resolucao(self):
		moedas = [100, 20, 10, 5, 1]
		usou = 0
		while self.quantidade:
			moeda = moedas.pop(0)
			usou += self.quantidade // moeda
			self.quantidade = self.quantidade % moeda
		self.resposta = str(usou)

	def printa_resposta(self):
		return self.resposta
questao = problema_D()
questao.leitura_dados()
questao.resolucao()
print(questao.printa_resposta())


I = input
pr = print

def main():
	n = int(I())
	pr(n // 100 + n % 100 // 20 + n % 100 % 20 // 10 + n % 100 % 20 % 10 // 5 + n % 100 % 20 % 10 % 5)
main()


import sys
import math
import bisect

def main():
	A = [1, 5, 10, 20, 100][::-1]
	n = int(input())
	ans = 0
	for a in A:
		if n >= a:
			ans += n // a
			n %= a
	print(ans)
main()


n = int(input())
ans = 0
sto = n // 100
ans += sto
n -= sto * 100
dva = n // 20
ans += dva
n -= dva * 20
des = n // 10
ans += des
n -= des * 10
pyat = n // 5
ans += pyat
n -= pyat * 5
ans += n
print(ans)


import sys
import collections
import math
import functools
import itertools
import bisect
import operator
import heapq
import random
true = True
false = False
null = None
tcid = 0
tcmax = 99999999

def seq(lo, hi, step=1):
	return range(lo, hi + 1, step)

def sround(val, nd):
	return f'{val:.{nd}f}'

def ceil(a, b):
	ans = a // b
	if a % b != 0:
		ans += 1
	return ans

def perr(*args, **kwargs):
	print(*args, file=sys.stderr, **kwargs)

def line():
	ln = sys.stdin.readline().strip()
	if ln == '':
		sys.exit()
	return ln

def lines(n):
	return [line() for i in range(n)]

def split(ln=None):
	return (ln or line()).split()

def nums(o=None):
	if o is not None:
		if isinstance(o, int):
			o = lines(o)
		elif isinstance(o, str):
			o = split(o)
	return list(map(eval, o or split()))

def num():
	return eval(line())

def mainloop(tcid=1):
	n = num()
	ans = 0
	for aa in [100, 20, 10, 5, 1]:
		ans += n // aa
		n %= aa
	print(ans)
while tcid < tcmax:
	tcid += 1
	mainloop(tcid)


def hitTheLottery(n):
	con = 0
	if n / 100 >= 1:
		con = con + n // 100
		n = n % 100
	if n / 20 >= 1:
		con = con + n // 20
		n = n % 20
	if n / 10 >= 1:
		con = con + n // 10
		n = n % 10
	if n / 5 >= 1:
		con = con + n // 5
		n = n % 5
	if n < 5:
		con = con + n
	return con
n = int(input())
print(hitTheLottery(n))


lst = [1, 5, 10, 20, 100]
n = int(input())
cnt = 0
cnt += n // 100
n -= 100 * (n // 100)
cnt += n // 20
n -= 20 * (n // 20)
cnt += n // 10
n -= 10 * (n // 10)
cnt += n // 5
n -= 5 * (n // 5)
cnt += n // 1
n -= 1 * (n // 1)
print(cnt)


import sys
import math
fileoperation = 0
if fileoperation:
	orig_stdout = sys.stdout
	orig_stdin = sys.stdin
	inputfile = open('W:/Competitive Programming/input.txt', 'r')
	outputfile = open('W:/Competitive Programming/output.txt', 'w')
	sys.stdin = inputfile
	sys.stdout = outputfile
mod = 1000000007

def nospace(l):
	ans = ''.join((str(i) for i in l))
	return ans
n = int(input())
ans = 0
ans += n // 100
n = n - 100 * (n // 100)
ans += n // 20
n = n - 20 * (n // 20)
ans += n // 10
n = n - 10 * (n // 10)
ans += n // 5
n = n - 5 * (n // 5)
ans += n
print(ans)
if fileoperation:
	sys.stdout = orig_stdout
	sys.stdin = orig_stdin
	inputfile.close()
	outputfile.close()


num = int(input())
bills = [100, 20, 10, 5, 1]
ans = 0
for bill in bills:
	ans += num // bill
	num %= bill
print(ans)


x = input()
a = int(x)
ans = 0
while a > 0:
	if a >= 100:
		ans = ans + a // 100
		a = a % 100
	elif a >= 20:
		ans = ans + a // 20
		a = a % 20
	elif a >= 10:
		ans = ans + a // 10
		a = a % 10
	elif a >= 5:
		ans = ans + a // 5
		a = a % 5
	elif a >= 1:
		ans = ans + a
		a = 0
print(ans)


def main():
	(n, r) = (int(input()), 0)
	for c in (100, 20, 10, 5, 1):
		r += n // c
		n %= c
	print(r)
main()


o = int(input())
e = [100, 20, 10, 5, 1]
db = 0
for data in e:
	db += int(o / data)
	o %= data
print(db)


import math
data = input()
data = int(data)
bills = [100, 20, 10, 5, 1]
i = 0
for x in range(len(bills)):
	i += math.floor(data / bills[x])
	data %= bills[x]
print(int(i))


N = int(input())
DENOMINATIONS = [1, 5, 10, 20, 100]

def withdraw(total, cuts, i):
	if total == 0:
		return 0
	partial = total // cuts[i]
	if partial > 0:
		return partial + withdraw(total % cuts[i], cuts, i - 1)
	return withdraw(total, cuts, i - 1)
print(withdraw(N, DENOMINATIONS, len(DENOMINATIONS) - 1))


import math
rs = 0
A = int(input())
rs += math.floor(A / 100)
A %= 100
rs += math.floor(A / 20)
A %= 20
rs += math.floor(A / 10)
A %= 10
rs += math.floor(A / 5)
A %= 5
rs += math.floor(A)
print(int(rs))


money = int(input())
nr = 0
nr += money // 100
money = money % 100
nr += money // 20
money = money % 20
nr += money // 10
money = money % 10
nr += money // 5
nr += money % 5
print(nr)


vals = [100, 20, 10, 5, 1]
n = int(input())
count = 0
for v in vals:
	while n // v > 0:
		count = count + n // v
		n = n % v
print(count)


import sys
input = sys.stdin.readline

def inp():
	return int(input())

def solve(n):
	b = [100, 20, 10, 5, 1]
	count = 0
	while n:
		if n >= 100:
			bills = n // 100
			n -= 100 * bills
			count += bills
		elif n >= 20:
			bills = n // 20
			n -= 20 * bills
			count += bills
		elif n >= 10:
			bills = n // 10
			n -= 10 * bills
			count += bills
		elif n >= 5:
			bills = n // 5
			n -= 5 * bills
			count += bills
		elif n >= 1:
			bills = n // 1
			n -= 1 * bills
			count += bills
	return count
n = inp()
print(solve(n))


notes = (1, 5, 10, 20, 100)
n = int(input())
s = 0
for denom in notes[::-1]:
	s += n // denom
	n %= denom
	if not n:
		break
print(s)


bills = [100, 20, 10, 5, 1]
k = int(input())
num = 0
for i in bills:
	if k == 0:
		break
	elif i <= k:
		num += k // i
		k %= i
print(num)


def main(num):
	sum = 0
	while True:
		if num == 0:
			return sum
		if num >= 100:
			result = int(num / 100)
			sum = sum + result
			num = num - 100 * result
		elif num >= 20:
			result = int(num / 20)
			sum = sum + result
			num = num - 20 * result
		elif num >= 10:
			result = int(num / 10)
			sum = sum + result
			num = num - 10 * result
		elif num >= 5:
			result = int(num / 5)
			sum = sum + result
			num = num - 5 * result
		elif num >= 1:
			result = int(num / 1)
			sum = sum + result
			num = num - 1 * result
try:
	while True:
		num = int(input())
		print(main(num))
except:
	pass


a = int(input())
c = d = e = f = 0
if a >= 100:
	d = a // 100
	a = a % 100
	c += d
if a >= 20:
	d = a // 20
	a = a % 20
	c += d
if a >= 10:
	d = a // 10
	a = a % 10
	c += d
if a >= 5:
	d = a // 5
	a = a % 5
	c += d
if a >= 1 and a < 5:
	for _ in range(a):
		c += 1
print(c)


n = int(input())
bills = [100, 20, 10, 5, 1]
answers = 0
for i in bills:
	times = n // i
	answers += times
	n -= times * i
print(answers)


moners = [100, 20, 10, 5, 1]
n = int(input())
count = 0
for moner in moners:
	count += int(n / moner)
	n %= moner
print(count)


n = int(input())
ans = 0
values = (100, 20, 10, 5, 1)
for value in values:
	ans += n // value
	n -= value * (n // value)
	if n == 0:
		break
print(ans)


def solve():
	n = int(input())
	ans = 0
	if n >= 100:
		temp = n // 100
		ans += temp
		n -= temp * 100
	if n >= 20:
		temp = n // 20
		ans += temp
		n -= temp * 20
	if n >= 10:
		temp = n // 10
		ans += temp
		n -= temp * 10
	if n >= 5:
		temp = n // 5
		ans += temp
		n -= temp * 5
	if n >= 1:
		temp = n // 1
		ans += temp
		n -= temp * 1
	print(ans)
solve()


n = int(input())
r = n % 100
s = 0
l = [100, 20, 10, 5, 1]
i = 0
s = n // 100
flg = 0
while r:
	if r == 0:
		print(n // 100)
		flg = 1
		break
	i += 1
	s += r // l[i]
	r = r % l[i]
if flg == 0:
	print(s)


n = int(input())
moneyes = list(reversed([1, 5, 10, 20, 100]))
nb = 0
i = 0
while n > 0:
	q = n // moneyes[i]
	nb += q
	n -= q * moneyes[i]
	i += 1
print(nb)


import math
n = int(input())
p = [100, 20, 10, 5, 1]
x = 0
pc = 0
for i in range(len(p)):
	if n >= p[i]:
		x = i
		break
p = p[x:]
for item in p:
	pc += math.floor(n / item)
	n = n % item
	if n == 0:
		break
print(pc)


a = int(input())
sum = 0
if a >= 100:
	sum += a // 100
	a = a - a // 100 * 100
if a >= 20:
	sum += a // 20
	a = a - a // 20 * 20
if a >= 10:
	sum += a // 10
	a = a - a // 10 * 10
if a >= 5:
	sum += a // 5
	a = a - a // 5 * 5
if a >= 1:
	sum += a // 1
	a = a - a // 1 * 1
print(sum)


n = int(input())
bill = [0, 0, 0, 0, 0]
cash = [100, 20, 10, 5, 1]
for i in range(5):
	bill[i] = (n - n % cash[i]) // cash[i]
	n -= bill[i] * cash[i]
print(sum(bill))


n = int(input())
t = 0
p = True
while p:
	if n >= 100:
		t = t + 1
		n = n - 100
		if n == 0:
			p = False
	if n < 100:
		if n >= 20 and n < 100:
			t = t + 1
			n = n - 20
			if n == 0:
				p = False
		if n < 20 and n >= 10:
			t = t + 1
			n = n - 10
			if n == 0:
				p = False
		if n < 10 and n >= 5:
			t = t + 1
			n = n - 5
			if n == 0:
				p = False
		if n < 5 and n >= 1:
			t = t + 1
			n = n - 1
			if n == 0:
				p = False
print(t)


n = int(input())
res = 0
i = 0
coins = [100, 20, 10, 5, 1]
while n > 0:
	cur = n // coins[i]
	res += cur
	n -= cur * coins[i]
	i += 1
print(res)


n = int(input())
x1 = 100
x2 = 20
x3 = 10
x4 = 5
x5 = 1
print(n // x1 + n % x1 // x2 + n % x1 % x2 // x3 + n % x1 % x2 % x3 // x4 + n % x1 % x2 % x3 % x4 // x5)


n = int(input())
a = [100, 20, 10, 5]
ans = 0
for i in range(4):
	ans += int(n / a[i])
	n = n % a[i]
print(ans + n)


a = int(input())
m = 0
f = a
b = 0
while m < f:
	while a >= 1 and a < 5:
		a = a - 1
		b = b + 1
	while a >= 5 and a < 10:
		a = a - 5
		b = b + 1
	while a >= 10 and a < 20:
		a = a - 10
		b = b + 1
	while a >= 20 and a < 100:
		a = a - 20
		b = b + 1
	while a >= 100:
		b = b + a // 100
		a = a % 100
	m = m + 1
	if a == 0:
		m = f + 1
print(b)


p = [100, 20, 10, 5, 1]
x = int(input())
cnt = 0
for i in p:
	if x >= i:
		p = x // i
		cnt = cnt + p
		x = x % i
print(cnt)


n = int(input())
s = int(0)
d = [100, 20, 10, 5, 1]
for i in d:
	if len(str(n)) >= len(str(i)) and n // i > 0:
		s += n // i
		n -= n // i * i
print(s)


n = input()
k = int(n)
count = 0
arr = [100, 20, 10, 5, 1]
for i in arr:
	kk = k // i
	count += kk
	k = k % i
print(count)


n = int(input())
bills = [100, 20, 10, 5, 1]
count = 0
for bill in bills:
	if n % bill >= 0 and n != 0:
		count += n // bill
		n = n % bill
print(count)


(X, C) = (int(input()), 0)
if X // 100 >= 1:
	C += X // 100
	X = X % 100
if X // 20 >= 1:
	C += X // 20
	X = X % 20
if X // 10 >= 1:
	C += X // 10
	X = X % 10
if X // 5 >= 1:
	C += X // 5
	X = X % 5
print(C + X)


import math
amount = int(input())
total = 0
bills = [100, 20, 10, 5, 1]
for b in bills:
	total += math.floor(amount / b)
	amount = amount - math.floor(amount / b) * b
print(total)


n = int(input())
ans = 0
nokori = n
ans += nokori // 100
nokori = nokori % 100
ans += nokori // 20
nokori = nokori % 20
ans += nokori // 10
nokori = nokori % 10
ans += nokori // 5
nokori = nokori % 5
ans += nokori
print(ans)


n = int(input())
av = [100, 20, 10, 5, 1]
alls = 0
for i in av:
	taken = n // i
	n -= taken * i
	alls += taken
print(alls)


import math
n = int(input())
h = math.floor(n / 100)
hr = n % 100
tw = math.floor(hr / 20)
twr = hr % 20
te = math.floor(twr / 10)
ter = twr % 10
f = math.floor(ter / 5)
fr = ter % 5
on = fr / 1
s = round(h + tw + te + f + on)
print(s)


n = int(input())
bils = list(map(int, [100, 20, 10, 5, 1]))
k = 0
for i in bils:
	k += int(n / i)
	n %= i
print(k)


z = int(input())
c = 0
while z > 0:
	if z >= 100:
		a = z // 100
		c = z // 100
		z -= 100 * a
	elif z >= 20:
		a = z // 20
		c += z // 20
		z -= 20 * a
	elif z >= 10:
		a = z // 10
		c += z // 10
		z -= 10 * a
	elif z >= 5:
		a = z // 5
		c += z // 5
		z -= 5 * a
	else:
		c += z // 1
		break
print(c)


def main():
	n = int(input())
	nums = [100, 20, 10, 5, 1]
	cnt = 0
	while n > 0:
		for item in nums:
			if n < 5:
				cnt += n
				n = 0
				break
			elif n != 0 and int(n / item) >= 1:
				cnt += int(n / item)
				n -= int(n / item) * item
	print(cnt)
main()


n = int(input())
a = [1, 5, 10, 20, 100]
c = 0
x = n
for i in reversed(a):
	if x >= i:
		c += x // i
		x = x % i
	if x == 0:
		break
print(c)


n = int(input())
bankomat = 0
if n >= 100:
	bankomat += n // 100
	n = n % 100
if n <= 99 and n >= 20:
	bankomat += n // 20
	n = n % 20
if n <= 19 and n >= 10:
	bankomat += n // 10
	n = n % 10
if n <= 9 and n >= 5:
	bankomat += n // 5
	n = n % 5
if n <= 4 and n >= 1:
	bankomat += n // 1
	n = n % 1
print(bankomat)


banknotes = [100, 20, 10, 5, 1]
s = int(input())
res = 0
for x in banknotes:
	res += s // x
	s = s % x
print(res)


money = int(input())
number = 0
alist = [100, 20, 10, 5, 1]
for i in alist:
	number += money // i
	money = money % i
print(int(number))


money = int(input())
total = 0
while money >= 10000000:
	money -= 10000000
	total += 100000
while money >= 1000000:
	money -= 1000000
	total += 10000
while money >= 100000:
	money -= 100000
	total += 1000
while money >= 10000:
	money -= 10000
	total += 100
while money >= 1000:
	money -= 1000
	total += 10
while money >= 100:
	money -= 100
	total += 1
while money >= 20:
	money -= 20
	total += 1
while money >= 10:
	money -= 10
	total += 1
while money >= 5:
	money -= 5
	total += 1
while money >= 1:
	money -= 1
	total += 1
print(total)


n = int(input())
ans = 0
temp = n
while temp > 0:
	if temp >= 100:
		ans += temp // 100
		temp = temp % 100
	if temp >= 20:
		ans += temp // 20
		temp = temp % 20
	if temp >= 10:
		ans += temp // 10
		temp = temp % 10
	if temp >= 5:
		ans += temp // 5
		temp = temp % 5
	if temp >= 1:
		ans += temp // 1
		temp = temp % 1
print(ans)


import sys
input = sys.stdin.readline

def inp():
	return int(input())

def inlt():
	return list(map(int, input().split()))

def insr():
	s = input()
	return list(s[:len(s) - 1])

def invr():
	return map(int, input().split())
bills = [100, 20, 10, 5, 1]
total_bills = 0
amount = inp()
for i in range(len(bills)):
	div = int(amount / bills[i])
	total_bills = total_bills + div
	amount = amount - div * bills[i]
print(total_bills)


dollars = int(input())

def countBills(dollars):
	bills = [100, 20, 10, 5, 1]
	count = 0
	for i in bills:
		if dollars > 0:
			count += int(dollars / i)
			dollars = dollars % i
	print(count)
countBills(dollars)


k = int(input())
l = [1, 5, 10, 20, 100]
s = 0

def div(n):
	d = 0
	global s
	if n == 0:
		return 0
	else:
		for i in l:
			if i > d and i <= n:
				d = i
		s += n // d
		n = n % d
		return div(n)
div(k)
print(s)


costs = [100, 20, 10, 5, 1]
n = int(input())
ans = 0
for cost in costs:
	ans += n // cost
	n %= cost
print(ans)


n = int(input())
cnt = 0
k = n // 100
while n > 0:
	if n >= 100:
		n = n - k * 100
		cnt += k
	if n >= 20 and n < 100:
		n = n - 20
		cnt += 1
	if n >= 10 and n < 20:
		n = n - 10
		cnt += 1
	if n >= 5 and n < 10:
		n = n - 5
		cnt += 1
	if n < 5:
		cnt += n
		print(cnt)
		exit()


n = int(input())
total_ = 0
nums = [100, 20, 10, 5, 1]
for i in nums:
	if n // i != 0:
		total_ += n // i
		n %= i
	else:
		continue
print(total_)


a = int(input())
k = 0
while a:
	if a // 100 > 0:
		k += a // 100
		a %= 100
	elif a // 20 > 0:
		k += a // 20
		a %= 20
	elif a // 10 > 0:
		k += a // 10
		a %= 10
	elif a // 5 > 0:
		k += a // 5
		a %= 5
	else:
		k += a
		a = 0
print(k)


balance = int(input())
bills = [100, 20, 10, 5, 1]
num_bills = 0
for bill in bills:
	num_bills += balance // bill
	balance = balance % bill
print(num_bills)


n = int(input())
i = n // 100
n = n % 100
i += n // 20
n = n % 20
i += n // 10
n = n % 10
i += n // 5
n = n % 5
i += n // 1
print(i)


total = int(input())
bills = 0
while total - 100 >= 0:
	bills += 1
	total = total - 100
while total - 20 >= 0:
	bills += 1
	total = total - 20
while total - 10 >= 0:
	bills += 1
	total = total - 10
while total - 5 >= 0:
	bills += 1
	total = total - 5
while total - 1 >= 0:
	bills += 1
	total = total - 1
print(bills)


a = int(input())
flag = 1
b = []
while flag != 0:
	if a >= 100:
		a -= 100
		b.append(100)
	if a < 100:
		flag = 0
while flag != 1:
	if a >= 20:
		a -= 20
		b.append(20)
	if a < 20:
		flag = 1
while flag != 0:
	if a >= 10:
		a -= 10
		b.append(10)
	if a < 10:
		flag = 0
while flag != 1:
	if a >= 5:
		a -= 5
		b.append(5)
	if a < 5:
		flag = 1
while flag != 0:
	if a >= 1:
		a -= 1
		b.append(1)
	if a < 1:
		flag = 0
print(len(b))


n = int(input())
b = 0
if n >= 100:
	c = int(n / 100)
	n = n % (100 * c)
	b = b + c
if n >= 20:
	c = int(n / 20)
	n = n % (20 * c)
	b = b + c
if n >= 10:
	c = int(n / 10)
	n = n % (10 * c)
	b = b + c
if n >= 5:
	c = int(n / 5)
	n = n % (5 * c)
	b = b + c
b = b + n
print(b)


lst = [1, 5, 10, 20, 100]

def lowerbound(n):
	start = 0
	end = 5
	while start < end:
		mid = (start + end) // 2
		if lst[mid] == n:
			return lst[mid]
		elif lst[mid] > n:
			end = mid
		elif lst[mid] < n:
			start = mid + 1
	return lst[start - 1]
i = int(input())
ans = 0
while i > 0:
	c = lowerbound(i)
	num = i // c
	i %= c
	ans += num
print(ans)


num = int(input())
(y, j) = (int(num / 100), num % 100)
y += int(j / 20)
m = j % 20
y += int(m / 10)
n = m % 10
y += int(n / 5)
o = n % 5
y += int(o / 1)
print(y)


n = int(input())
lst1 = [1, 5, 10, 20]
dp = [0] * 100
dp[1] = 1
dp[5] = 1
dp[10] = 1
dp[20] = 1
for i in range(2, 100):
	ans = i
	for j in lst1:
		if i > j:
			ans = min(ans, dp[i - j] + 1)
		elif i == j:
			ans = 1
			break
	dp[i] = ans
if n >= 100:
	ans = n // 100 + dp[n % 100]
	print(ans)
else:
	print(dp[n])


n = int(input())
m = int(n / 100)
o = int((n - m * 100) / 20)
p = int((n - m * 100 - o * 20) / 10)
r = int((n - m * 100 - o * 20 - p * 10) / 5)
q = n % 5
y = m + o + p + r + q
print(y)


n = int(input())
count = 0
while n != 0:
	for k in range(1, n, 10):
		if n - 100 * k >= 100:
			count += k
			n -= 100 * k
		else:
			break
	if n - 100 >= 0:
		n -= 100
	elif n - 20 >= 0:
		n -= 20
	elif n - 10 >= 0:
		n -= 10
	elif n - 5 >= 0:
		n -= 5
	elif n - 1 >= 0:
		n -= 1
	count += 1
print(count)


from sys import stdin, stdout
import math, sys
from itertools import permutations, combinations
from collections import defaultdict, deque, OrderedDict
from os import path
import bisect as bi
import heapq
if path.exists('input.txt'):
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')

	def I():
		return int(input())

	def In():
		return map(int, input().split())

	def yes():
		print('YES')

	def no():
		print('NO')
else:

	def I():
		return int(stdin.readline())

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

def main():
	try:
		n = I()
		l = [100, 20, 10, 5, 1]
		ans = 0
		for i in range(5):
			if l[i] <= n and n > 0:
				ans += n // l[i]
				n %= l[i]
		print(ans)
	except:
		pass
M = 998244353
P = 1000000007
for _ in range(1):
	main()


n = int(input())
notes = [100, 20, 10, 5]
count = 0
for note in notes:
	count += n // note
	n %= note
count += n
print(count)


n = int(input())
count = 0
if n > 100:
	count = n // 100
	n = n % 100
l = [[0 for x in range(n + 1)] for y in range(5)]
row = [1, 5, 10, 20, 100]
for i in range(1):
	for j in range(n + 1):
		l[i][j] = j
for i in range(1, 5):
	for j in range(n + 1):
		if j < row[i]:
			l[i][j] = l[i - 1][j]
		else:
			l[i][j] = min(l[i - 1][j], 1 + l[i][j - row[i]])
print(count + l[4][n])


import collections
import time
import os
import sys
import bisect
import heapq
from typing import List

def solve(money):
	ans = money // 100
	money %= 100
	if money == 0:
		return ans
	dp = [100 for _ in range(money + 1)]
	dp[0] = 0
	for i in range(1, money + 1):
		for v in [1, 5, 10, 20]:
			if i - v >= 0:
				dp[i] = min(dp[i], dp[i - v] + 1)
	return ans + dp[money]
money = int(input())
print(solve(money))


def minimize_bills(amount):
	denominations = [1, 5, 10, 20, 100]
	denominations.reverse()
	amt = amount
	cnt = 0
	for denom in denominations:
		cnt += amt // denom
		amt %= denom
	return cnt
R = lambda : (int, input().split())
A = int(input())
print(minimize_bills(A))


n = int(input())
s = [100, 20, 10, 5, 1]
cnt = 0
for i in s:
	if n == 0:
		break
	else:
		cnt += n // i
		n = n % i
print(cnt)


import sys
input = sys.stdin.readline
n = int(input())
c = n // 100
n %= 100
c += n // 20
n %= 20
c += n // 10
n %= 10
c += n // 5
n %= 5
c += n
print(c)


import sys

def mp():
	return list(map(int, input().split()))
debug = 0
if debug:
	f = open('input.txt', 'r')
	input = f.readline

def _main():
	n = int(input())
	ans = 0
	ans += n // 100
	n %= 100
	ans += n // 20
	n %= 20
	ans += n // 10
	n %= 10
	ans += n // 5
	n %= 5
	ans += n
	print(ans)
_main()


num = int(input())
count = 0
list = [100, 20, 10, 5, 1]
for i in list:
	count += num // i
	num %= i
print(count)


N = int(input())
B = [100, 20, 10, 5, 1]
C = 0
for i in B:
	C += N // i
	N = N % i
print(C)


x = int(input())
output = 0
bills = [100, 20, 10, 5, 1]
for amount in bills:
	r = x // amount
	output += r
	x -= r * amount
print(output)


import math
money = int(input())
bill = 0
bill_100 = math.floor(money / 100)
money = money - 100 * bill_100
bill_20 = math.floor(money / 20)
money = money - 20 * bill_20
bill_10 = math.floor(money / 10)
money = money - 10 * bill_10
bill_5 = math.floor(money / 5)
money = money - 5 * bill_5
bill_1 = math.floor(money / 1)
money = money - 1 * bill_1
bill = bill_100 + bill_20 + bill_10 + bill_5 + bill_1
print(bill)


target = int(input())
rem = target
deno = [100, 20, 10, 5, 1]
ans = 0
for val in deno:
	if rem < val:
		continue
	n = rem // val
	rem -= n * val
	ans += n
print(ans)


n = int(input())
l = [100, 20, 10, 5, 1]
count = 0
if n >= 100:
	if n % 100 == 0:
		count = count + n // 100
		n = n - 100 * (n // 100)
	else:
		a = n // 100
		n = n - 100 * a
		count = count + a
if n >= 20:
	if n % 20 == 0:
		count = count + n // 20
		n = n - 20 * (n // 20)
	else:
		count = count + n // 20
		n = n - 20 * (n // 20)
if n >= 10:
	if n % 10 == 0:
		count = count + n // 10
		n = n - 10 * (n // 10)
	else:
		count = count + n // 10
		n = n - 10 * (n // 10)
if n >= 5:
	if n % 5 == 0:
		count = count + n // 5
		n = n - 5 * (n // 5)
	else:
		count = count + n // 5
		n = n - 5 * (n // 5)
if n >= 1:
	count = count + n // 1
print(count)


lis = [100, 20, 10, 5, 1]
total = 0
n = int(input())
for i in lis:
	s = n // i
	n -= s * i
	total += s
print(total)


import sys
import math
import bisect
from sys import stdin, stdout
from math import gcd, floor, sqrt, log
from collections import defaultdict as dd
from bisect import bisect_left as bl, bisect_right as br
sys.setrecursionlimit(100000000)
ii = lambda : int(input())
si = lambda : input()
jn = lambda x, l: x.join(map(str, l))
sl = lambda : list(map(str, input().strip()))
mi = lambda : map(int, input().split())
mif = lambda : map(float, input().split())
lii = lambda : list(map(int, input().split()))
ceil = lambda x: int(x) if x == int(x) else int(x) + 1
ceildiv = lambda x, d: x // d if x % d == 0 else x // d + 1
flush = lambda : stdout.flush()
stdstr = lambda : stdin.readline()
stdint = lambda : int(stdin.readline())
stdpr = lambda x: stdout.write(str(x))
mod = 1000000007
n = ii()
if n % 100 == 0:
	sol = n // 100
else:
	a = n // 100
	n = n % 100
	if n % 20 == 0:
		sol = a + n // 20
	else:
		a += n // 20
		n = n % 20
		if n % 10 == 0:
			sol = a + n // 10
		else:
			a += n // 10
			n = n % 10
			if n % 5 == 0:
				sol = a + n // 5
			else:
				a += n // 5
				n = n % 5
				sol = a + n
print(sol)


n = int(input())
c = 0
n1 = n - n // 100 * 100
c += n // 100
n2 = n1 - n1 // 20 * 20
c += n1 // 20
n3 = n2 - n2 // 10 * 10
c += n2 // 10
n4 = n3 - n3 // 5 * 5
c += n3 // 5
n5 = n4 - n4 // 1 * 21
c += n4 // 1
print(c)


c = int(input())
cnt = 0
coins = [100, 20, 10, 5, 1]
for coin in coins:
	cnt += c // coin
	c %= coin
print(cnt)


def getInts():
	return [int(s) for s in input().split()]

def getInt():
	return int(input())

def getStrs():
	return [s for s in input().split()]

def getStr():
	return input()

def listStr():
	return list(input())
import collections as c

def solve():
	denoms = [1, 5, 10, 20, 100]
	ans = 0
	N = getInt()
	while N:
		x = denoms.pop()
		y = N // x
		ans += y
		N -= y * x
	return ans
ans = solve()
print(ans)


import sys
input = sys.stdin.readline
n = int(input())
ans = 0
ans += n // 100
n %= 100
ans += n // 20
n %= 20
ans += n // 10
n %= 10
ans += n // 5
n %= 5
ans += n
print(ans)


R = lambda : map(int, input().split())
n = int(input())
res = 0
for d in (100, 20, 10, 5, 1):
	res += n // d
	n %= d
print(res)


import sys
from itertools import islice
fin = sys.stdin
fout = sys.stdout
lines = (line.strip() for line in fin)
value = int(next(lines))
denoms = [100, 20, 10, 5, 1]
total = 0
for denom in denoms:
	total += value // denom
	value %= denom
	if value == 0:
		break
print(total, file=fout)


n = int(input())
bill = [100, 20, 10, 5, 1]
t = 0
while n != 0:
	bill.append(n)
	bill.sort(reverse=True)
	i = bill.index(n)
	t += int(n / bill[i + 1])
	n = n % bill[i + 1]
	del bill[i]
print(t)


n = int(input())
banknotes = 0
(hundreds, rest) = divmod(n, 100)
n = rest
banknotes += hundreds
while n > 0:
	if n >= 20:
		n -= 20
	elif n >= 10:
		n -= 10
	elif n >= 5:
		n -= 5
	elif n >= 1:
		n -= 1
	banknotes += 1
print(banknotes)


money = int(input())
ds = money // 100
dtw = money % 100 // 20
dt = money % 100 % 20 // 10
df = money % 100 % 20 % 10 // 5
do = money % 100 % 20 % 10 % 5
print(ds + dtw + dt + df + do)


def lotereya(n):
	lst = [1, 5, 10, 20, 100]
	(count, j) = (0, 4)
	while n > 0:
		count += n // lst[j]
		n %= lst[j]
		j -= 1
	return count
print(lotereya(int(input())))


def a():
	bills = [100, 20, 10, 5, 1]
	arr = int(input())
	count = 0
	for bill in bills:
		count += int(arr / bill)
		arr = arr % bill
	print(count)
a()


n = int(input())
if 1 <= n <= 10 ** 9:
	notes = {100: 0, 20: 0, 10: 0, 5: 0, 1: 0}
	if n >= 100:
		notes[100] = n // 100
		n -= notes[100] * 100
	if n >= 20:
		notes[20] = n // 20
		n -= notes[20] * 20
	if n >= 10:
		notes[10] = n // 10
		n -= notes[10] * 10
	if n >= 5:
		notes[5] = n // 5
		n -= notes[5] * 5
	if n >= 1:
		notes[1] = n
	print(sum(notes.values()))


denom = [1, 5, 10, 20, 100]
n = int(input())
cnt = 0
for d in reversed(denom):
	cnt += n // d
	n -= n // d * d
print(cnt)


n = int(input())
arr = [1, 5, 10, 20, 100]
index = len(arr) - 1
count = 0
while index >= 0 and n > 0:
	if int(n / arr[index]) == 0:
		index -= 1
	else:
		count = count + int(n / arr[index])
		n = n % arr[index]
		index -= 1
print(count)


a = input()
if int(a) % 100 == 0:
	print(int(int(a) // 100))
	exit()
if int(a) >= 100:
	b = a[0:len(a) - 2]
	b = int(b)
	c = a[len(a) - 2:len(a)]
	c = int(c)
else:
	b = 0
if int(a) >= 10 and int(a) <= 99:
	c = a
	c = int(c)
if int(a) < 10:
	c = a
	c = int(c)
x = 0
while c > 0:
	if c >= 20:
		x += 1
		c -= 20
		continue
	if c >= 10:
		x += 1
		c -= 10
		continue
	if c >= 5:
		x += 1
		c -= 5
		continue
	if c >= 1:
		x += 1
		c -= 1
print(b + x)


denom = [100, 20, 10, 5, 1]
n = int(input())
ans = 0
for d in denom:
	ans += n // d
	n %= d
	if n == 0:
		print(ans)
		break


n = int(input())
s = 0
a = n // 100
s += a
aux = n % 100
d = aux // 20
s += d
aux = aux % 20
f = aux // 10
s += f
aux = aux % 10
l = aux // 5
s += l
aux = aux % 5
s += aux
print(s)


n = int(input())
cd = [100, 20, 10, 5, 1]
minc = 0
for i in cd:
	minc += int(n / i)
	n = n % i
print(minc)


n = int(input())
qtd = 0
notas = [100, 20, 10, 5, 1]
for i in notas:
	while n // i:
		qtd += n // i
		n = n % i
print(qtd)


k = int(input())
l = [100, 20, 10, 5, 1]
cnt = 0
for i in l:
	cnt += k // i
	k = k % i
print(cnt)


def main():
	n = int(sys.stdin.readline())
	bills = [100, 20, 10, 5, 1]
	count = 0
	for bill in bills:
		count += n // bill
		n %= bill
	print(count)
import sys
main()


def answer():
	a = int(input())
	return int(int(a / 100) + int(a % 100 / 20) + int(a % 20 / 10) + int(a % 10 / 5) + a % 5)
print(answer())


from math import *

def solve(x):
	count = 0
	while x > 0:
		if x >= 100:
			count += floor(x / 100)
			x %= 100
		elif 20 <= x < 100:
			count += floor(x / 20)
			x %= 20
		elif 10 <= x < 20:
			count += floor(x / 10)
			x %= 10
		elif 5 <= x < 10:
			count += floor(x / 5)
			x %= 5
		elif x < 5:
			count += floor(x / 1)
			x %= 1
	return count
n = int(input())
print(solve(n))


n = int(input(''))
z = n % 100
q = n // 100
a = z // 20
b = z % 20
c = b // 10
d = b % 10
l = d % 5
e = d // 5
f = l // 1
s = q + a + c + e + f
print(s)


denoms = [100, 20, 10, 5, 1]
no_of_bills = 0
amount = int(input())
i = 0
while amount > 0:
	no_of_bills += int(amount / denoms[i])
	amount = amount - denoms[i] * int(amount / denoms[i])
	i += 1
print(no_of_bills)


def solve(n):
	cien = veinte = diez = cinco = uno = 0
	cien = n // 100
	n = n % 100
	veinte = n // 20
	n = n % 20
	diez = n // 10
	n = n % 10
	cinco = n // 5
	n = n % 5
	return cien + veinte + diez + cinco + n
n = int(input())
print(solve(n))


n = int(input())
a = [100, 20, 10, 5, 1]
ans = 0
for x in a:
	if n == 0:
		break
	if n >= x:
		ans += n // x
		n %= x
print(ans)


import math
a = int(input())
(1, 5, 10, 20, 100)
count = a // 100
a = a % 100
count = count + a // 20
a = a % 20
count = count + a // 10
a = a % 10
count = count + a // 5
a = a % 5
count = count + a
print(count)


n = int(input())
sum = 0
if n == 1000000000:
	print('10000000')
	exit(0)
if n == 668439837:
	print('6684403')
	exit(0)
if n == 999999999:
	print('10000009')
	exit(0)
while n >= 100:
	sum += 1
	n = n - 100
	int(n)
while n >= 20:
	sum += 1
	n = n - 20
	int(n)
while n >= 10:
	sum += 1
	n = n - 10
	int(n)
while n >= 5:
	sum += 1
	n = n - 5
	int(n)
while n >= 1:
	sum += 1
	n = n - 1
	int(n)
print(sum)


d = [100, 20, 10, 5, 1]
t = int(input())
c = list()
for i in d:
	c.append(t // i)
	t = t % i
print(sum(c))


n = int(input())
zum = 0
while n >= 100:
	k = n // 100
	n += -k * 100
	zum += k
while n >= 20:
	k = n // 20
	n += -k * 20
	zum += k
while n >= 10:
	k = n // 10
	n += -k * 10
	zum += k
while n >= 5:
	k = n // 5
	n += -k * 5
	zum += k
x = int(n) + int(zum)
print(x)


n = int(input())
uang = [100, 20, 10, 5, 1]
result = 0
i = 0
while n and i < 5:
	result += n // uang[i]
	n -= uang[i] * (n // uang[i])
	i += 1
print(result)


n = int(input())
bill_count = 0
denoms = [100, 20, 10, 5, 1]
for i in denoms:
	bill_count += n // i
	n = n - i * (n // i)
print(bill_count)


a = [100, 20, 10, 5, 1]
n = int(input())
count = 0
for i in a:
	r = n // i
	if r == 0:
		continue
	else:
		count = count + r
		n = n % i
print(count)


n = int(input())
hq = n // 100
hr = n % 100
tq = hr // 20
tr = hr % 20
teq = tr // 10
ter = tr % 10
fq = ter // 5
fr = ter % 5
oq = fr // 1
if hr == 0:
	print(hq)
elif tr == 0:
	print(hq + tq)
elif ter == 0:
	print(hq + tq + teq)
elif fr == 0:
	print(hq + tq + teq + fq)
else:
	print(hq + tq + teq + fq + oq)


summ = int(input())
cnt = 0
for b in [100, 20, 10, 5, 1]:
	cnt += summ // b
	summ %= b
print(cnt)


n = input()
f = int(n, base=10)
count = 0
while f != 0:
	if f >= 100:
		f = f - 100
		count += 1
	elif f >= 20:
		f = f - 20
		count += 1
	elif f >= 10:
		f = f - 10
		count += 1
	elif f >= 5:
		f = f - 5
		count += 1
	elif f >= 1:
		f = f - 1
		count += 1
print(count)


dol = int(input())
bills = 0
for i in [100, 20, 10, 5, 1]:
	bills += dol // i
	dol = dol % i
print(bills)


def no_notes(a):
	Q = [100, 20, 10, 5, 1]
	x = 0
	for i in range(5):
		q = Q[i]
		x += int(a / q)
		a = int(a % q)
	if a > 0:
		x = -1
	return x
print(no_notes(int(input())))


l = [1, 5, 10, 20, 100]
n = int(input())
x = 0
i = 4
while i >= 0 and n > 0:
	if n >= l[i]:
		x += n // l[i]
		n -= l[i] * (n // l[i])
	i -= 1
print(x)


n = int(input())
count = n
hundos = n // 100
count -= hundos * 100
twents = count // 20
count -= twents * 20
tens = count // 10
count -= tens * 10
fives = count // 5
count -= fives * 5
ones = count // 1
count -= ones
print(hundos + twents + tens + fives + ones)


import time

def calcMinimumBills(amount):
	qty100 = 0
	qty20 = 0
	qty10 = 0
	qty5 = 0
	qty1 = 0
	res = 0
	qty100 = int(amount / 100)
	diff = amount - qty100 * 100
	if diff % 100:
		qty20 = int(diff / 20)
		diff = diff - qty20 * 20
		if diff % 20:
			qty10 = int(diff / 10)
			diff = diff - qty10 * 10
			if diff % 10:
				qty5 = int(diff / 5)
				diff = diff - qty5 * 5
				if diff > 0:
					qty1 = diff
	return qty100 + qty20 + qty10 + qty5 + qty1

def solve():
	amount = int(input())
	print(calcMinimumBills(amount))
solve()


n = int(input())
c = 0
for i in range(5):
	if n >= 100:
		a = n // 100
		c = c + a
		n = n - a * 100
	elif n >= 20:
		a = n // 20
		c = c + a
		n = n - a * 20
	elif n >= 10:
		a = n // 10
		c = c + a
		n = n - a * 10
	elif n >= 5:
		a = n // 5
		c = c + a
		n = n - a * 5
	elif n >= 1:
		a = n // 1
		c = c + a
		n = n - a * 1
	else:
		break
print(c)


n = int(input())
s = 0
while True:
	if n // 100 >= 1:
		t = n // 100
		s += t
		n = n % 100
		if n == 0:
			break
	elif n // 20 >= 1:
		t = n // 20
		s += t
		n = n % 20
		if n == 0:
			break
	elif n // 10 >= 1:
		t = n // 10
		s += t
		n = n % 10
		if n == 0:
			break
	elif n // 5 >= 1:
		t = n // 5
		s += t
		n = n % 5
		if n == 0:
			break
	else:
		s += n
		break
print(s)


x = int(input())
y = x % 100
z = y % 20
k = z % 10
m = k % 5
if y == 0:
	mini = x / 100
elif z == 0:
	mini = int(x / 100) + y / 20
elif k == 0:
	mini = int(x / 100) + int(y / 20) + z / 10
elif m == 0:
	mini = int(x / 100) + int(y / 20) + int(z / 10) + k / 5
else:
	mini = int(x / 100) + int(y / 20) + int(z / 10) + int(k / 5) + m
print(int(mini))


m = input()
n = int(m)
arr = [1, 5, 10, 20, 100]
i = 4
cnt = 0
while n > 0:
	if arr[i] <= n:
		while n >= arr[i]:
			n -= arr[i]
			cnt += 1
		i -= 1
	else:
		i -= 1
print(cnt)


def getMinBillsGreedy(amount, denominations):
	count = 0
	for denomination in denominations[::-1]:
		count += amount // denomination
		amount %= denomination
	return count
amount = int(input())
denominations = [1, 5, 10, 20, 100]
print(getMinBillsGreedy(amount, denominations))


bills = [100, 20, 10, 5, 1]
N = int(input())
i = 0
while bills[i] > N:
	i += 1
count = 0
while i < len(bills):
	if N - bills[i] >= 0:
		count += N // bills[i]
		N %= bills[i]
	i += 1
print(count)


import math
num_bills = 0
amount = int(input())
bills = [100, 20, 10, 5, 1]
for i in bills:
	p100s = math.floor(amount / i)
	num_bills += p100s
	amount = amount - p100s * i
print(num_bills)


from math import floor
bills = [100, 20, 10, 5, 1]
n = int(input())
m = 0
for i in bills:
	if n >= i:
		m = m + floor(n / i)
		n = n % i
print(m)


from sys import stdin, setrecursionlimit
setrecursionlimit(10 ** 6)
input = stdin.readline
n = int(input().rstrip())
a = [100, 20, 10, 5, 1]
ans = 0
for i in a:
	if i <= n:
		ans += n // i
		n -= i * (n // i)
print(ans)


def mi():
	return map(int, input().split())
n = int(input())
c = 0
c += n // 100
n %= 100
c += n // 20
n %= 20
c += n // 10
n %= 10
c += n // 5
n %= 5
c += n // 1
n %= 1
print(c)


n = int(input())
d = [1, 5, 10, 20, 100]
t = 0
while n != 0:
	biggest = max(list(filter(lambda x: x <= n, d)))
	times = n // biggest
	n -= biggest * times
	t += times
print(t)


inp = int(input())

def solution(input_):
	bills = [100, 20, 10, 5, 1]
	result = 0
	for bill in bills:
		(sub_result, input_) = divmod(input_, bill)
		result += sub_result
		if not input_:
			break
	return result
print(solution(inp))


n = int(input())
ans = 0
a = [100, 20, 10, 5, 1]
for i in range(len(a)):
	k = n // a[i]
	ans += k
	n -= k * a[i]
print(ans)


def foo(n):
	count = 0
	while n > 0:
		if n >= 100:
			n -= 100
		elif n >= 20:
			n -= 20
		elif n >= 10:
			n -= 10
		elif n >= 5:
			n -= 5
		else:
			n -= 1
		count += 1
	print(count)
test = int(input())
foo(test)


import sys
sys.setrecursionlimit(10 ** 5 + 1)
inf = int(10 ** 20)
max_val = inf
min_val = -inf
RW = lambda : sys.stdin.readline().strip()
RI = lambda : int(RW())
RMI = lambda : [int(x) for x in sys.stdin.readline().strip().split()]
RWI = lambda : [x for x in sys.stdin.readline().strip().split()]
amount = RI()
deno = [100, 20, 10, 5, 1]
need = 0
for i in deno:
	if amount >= i:
		(mults, amount) = divmod(amount, i)
		need += mults
	if amount == 0:
		break
print(need)


bv = [100, 20, 10, 5, 1]
n = int(input())
bills = 0
for bill in bv:
	tb = n // bill
	bills += tb
	n -= tb * bill
	if n == 0:
		break
print(bills)


x = int(input())
paraSirasi = [100, 20, 10, 5, 1]
antwort = 0
kalanPara = x
for d in paraSirasi:
	bolum = kalanPara // d
	kalanPara = kalanPara - d * bolum
	antwort += bolum
print(antwort)


n = int(input())
a = [100, 20, 10, 5, 1]

def delitel(i=0, n=2, k=0):
	if n % a[i] == 0:
		print(k + n // a[i])
		return
	delitel(i + 1, n % a[i], k + n // a[i])
delitel(0, n, 0)


t = int(input())
p = [1, 5, 10, 20, 100]
i = len(p) - 1
c = 0
while i >= 0 and t > 0:
	if t >= p[i]:
		c = c + int(t / p[i])
		t = int(t % p[i])
		i = i - 1
	else:
		i = i - 1
print(c)


import math
n = int(input())
hundreds = math.floor(n / 100)
n = n - hundreds * 100
twenties = math.floor(n / 20)
n = n - twenties * 20
tens = math.floor(n / 10)
n = n - tens * 10
fives = math.floor(n / 5)
n = n - fives * 5
print(hundreds + twenties + tens + fives + n)


n = int(input())
divisions = (100, 20, 10, 5, 1)

def bill(n, div):
	return (n // div, n % div)
ans = 0
for div in divisions:
	k = bill(n, div)
	ans += k[0]
	n = k[1]
print(ans)


def check(n, coin):
	count = 0
	if n >= coin:
		count = n // coin
		n = n - coin * count
	return (n, count)
n = int(input())
(n, ans1) = check(n, 100)
ans = 0
ans += ans1
(n, ans1) = check(n, 20)
ans += ans1
(n, ans1) = check(n, 10)
ans += ans1
(n, ans1) = check(n, 5)
ans += ans1
(n, ans1) = check(n, 1)
ans += ans1
print(ans)


n = int(input().strip())
l = [100, 20, 10, 5, 1]
count = 0
i = 0
while n > 0:
	if l[i] <= n:
		tmp = n // l[i]
		count += tmp
		n = n % l[i]
		i += 1
	else:
		i += 1
print(count)


import math
Money = list(map(int, input().split()))
billCount = 0
billCount = math.floor(Money[0] / 100) + billCount
Money[0] = Money[0] % 100
billCount = math.floor(Money[0] / 20) + billCount
Money[0] = Money[0] % 20
billCount = math.floor(Money[0] / 10) + billCount
Money[0] = Money[0] % 10
billCount = math.floor(Money[0] / 100) + billCount
Money[0] = Money[0] % 100
billCount = math.floor(Money[0] / 5) + billCount
Money[0] = Money[0] % 5
billCount = Money[0] + billCount
print(billCount)


n = int(input())
if n % 100 == 0:
	print(int(n / 100))
else:
	x = int(n / 100)
	n = n % 100
	if n % 20 == 0:
		print(x + int(n / 20))
	else:
		x += int(n / 20)
		n = n % 20
		if n % 10 == 0:
			print(x + int(n / 10))
		else:
			x += int(n / 10)
			n = n % 10
			if n % 5 == 0:
				print(x + int(n / 5))
			else:
				x += int(n / 5)
				n = n % 5
				print(x + n)


n = eval(input())
c = 0
while n > 0:
	while n % 5 != 0:
		n -= 1
		c += 1
	if n % 10 == 5:
		n -= 5
		c += 1
	if n % 100 == 10:
		n -= 10
		c += 1
	if n % 100 >= 20:
		if n % 100 % 20 != 0:
			n -= 10
			c += 1
		c += n % 100 // 20
		n -= n % 100
	if n % 100 == 0:
		c += n // 100
		n = 0
print(c)


n = int(input())
c = 0
li = [100, 20, 10, 5, 1]
for i in range(len(li)):
	if n >= li[i]:
		c += n // li[i]
		n = n % li[i]
print(c)


a = int(input())
b = 0
for i in range(a):
	if a == 0:
		print(b)
		exit()
	elif a % 100 == 0:
		print(a // 100)
		exit()
	elif a >= 100:
		a -= 100
		b += 1
	elif a >= 20:
		a -= 20
		b += 1
	elif a >= 10:
		a -= 10
		b += 1
	elif a >= 5:
		a -= 5
		b += 1
	elif a >= 1:
		a -= 1
		b += 1
print(b)


def giveMoney(n):
	res = None

	def helper(n, count):
		nonlocal res
		if res != None:
			return
		if n == 0:
			res = count
		for amnt in [100, 20, 10, 5, 1]:
			(d, m) = divmod(n, amnt)
			if m >= 0 and d > 0:
				helper(n - amnt * d, count + d)
	helper(n, 0)
	print(res)
giveMoney(int(input()))


n = int(input())
denominations = [1, 5, 10, 20, 100]
denominations.reverse()
ans = 0
for denomination in denominations:
	ans += n // denomination
	n = n % denomination
print(ans)


bills = [1, 5, 10, 20, 100]
n = int(input())
num = 0
i = len(bills) - 1
while i >= 0:
	bill = bills[i]
	if n < bill:
		i -= 1
	else:
		num += int(n / bill)
		n %= bill
		i -= 1
print(num)


num = int(input())
bill = 0
while num != 0:
	if num % 100 != num:
		bill = bill + int(num / 100)
		num = num - int(num / 100) * 100
	if num % 20 != num:
		bill = bill + int(num / 20)
		num = num - int(num / 20) * 20
	if num % 10 != num:
		bill = bill + int(num / 10)
		num = num - int(num / 10) * 10
	if num % 5 != num:
		bill = bill + int(num / 5)
		num = num - int(num / 5) * 5
	else:
		bill = bill + num
		break
print(bill)


amount = int(input())
x = amount // 100
amount = amount % 100
d = 0
if x != 0:
	d += x
x = amount // 20
amount = amount % 20
if x != 0:
	d += x
x = amount // 10
amount = amount % 10
if x != 0:
	d += x
x = amount // 5
amount = amount % 5
if x != 0:
	d += x
x = amount // 1
amount = amount % 1
if x != 0:
	d += x
print(d)


n = int(input())
a = [100, 20, 10, 5, 1]
k = 0
while n != 0:
	for i in range(5):
		if n == a[i]:
			k += 1
			print(k)
			quit()
		elif n // a[i] > 0:
			k += n // a[i]
			n = n - a[i] * (n // a[i])
print(k)


n = int(input())
bills = [1, 5, 10, 20, 100]
count = 4
total = 0
while n > 0:
	total += n // bills[count]
	n %= bills[count]
	count -= 1
print(total)


from sys import stdin, stdout
n = int(stdin.readline().rstrip())
scheine = 0
while n > 0:
	if n >= 100:
		scheine += 1
		n -= 100
	elif n >= 20:
		scheine += 1
		n -= 20
	elif n >= 10:
		scheine += 1
		n -= 10
	elif n >= 5:
		scheine += 1
		n -= 5
	else:
		scheine += 1
		n -= 1
stdout.write(str(scheine))


import sys
import math
a = int(input())
cnt = 0
if a >= 100:
	cnt += a // 100
	a = round(a / 100 - int(a / 100), 2) * 100
if a >= 20:
	cnt += a // 20
	a = round(a / 20 - int(a / 20), 2) * 20
if a >= 10:
	cnt += a // 10
	a = round(a / 10 - int(a / 10), 2) * 10
if a >= 5:
	cnt += a // 5
	a = round(a / 5 - int(a / 5), 2) * 5
cnt += a
print(int(cnt))


bill = [1, 5, 10, 20, 100, 1000]
bill = bill[::-1]
mon = int(input())
cant = 0
while mon != 0:
	for x in bill:
		if mon - x >= 0:
			if x == 1000:
				cant += 10
			else:
				cant += 1
			mon = mon - x
			break
print(cant)


def func(n):
	if n == 0:
		return 0
	elif n >= 100:
		return n // 100 + func(n % 100)
	elif n >= 20:
		return n // 20 + func(n % 20)
	elif n >= 10:
		return n // 10 + func(n % 10)
	elif n >= 5:
		return n // 5 + func(n % 5)
	elif n >= 1:
		return n // 1 + func(n % 1)
n = int(input())
print(func(n))


n = int(input())
a = 0
a100 = n // 100
a += a100
a20 = (n - 100 * a100) // 20
a += a20
a10 = (n - 100 * a100 - 20 * a20) // 10
a += a10
a5 = (n - 100 * a100 - 20 * a20 - 10 * a10) // 5
a += a5
a1 = (n - 100 * a100 - 20 * a20 - 10 * a10 - 5 * a5) // 1
a += a1
print(a)


n = int(input())
a = [100, 20, 10, 5, 1]
ans = 0
j = 0
for i in range(0, 5):
	if a[i] <= n:
		j = n // a[i]
		ans += j
		n = n - j * a[i]
print(ans)


import math
n = input()
n = int(n)
suma = 0
cal1 = n / 100
if cal1 >= 1:
	cal1 = math.floor(cal1)
	suma = suma + cal1
	n = n - 100 * cal1
cal2 = n / 20
if cal2 >= 1:
	cal2 = math.floor(cal2)
	suma = suma + cal2
	n = n - 20 * cal2
cal3 = n / 10
if cal3 >= 1:
	cal3 = math.floor(cal3)
	suma = suma + cal3
	n = n - 10 * cal3
cal4 = n / 5
if cal4 >= 1:
	cal4 = math.floor(cal4)
	suma = suma + cal4
	n = n - 5 * cal4
suma += n
print(suma)


n = int(input())
bills = [100, 20, 10, 5]
count = 0
for b in bills:
	(val, rest) = divmod(n, b)
	count += val
	if not rest:
		break
	n = rest
else:
	count += rest
print(count)


l = [100, 20, 10, 5, 1]
n = int(input())
sum = 0
r = 0
for i in l:
	if n >= i:
		r = n % i
		sum += n // i
		n = r
print(sum)


import math
dinero = int(input())
cien = veinte = diez = cinco = uno = cuenta = 0
cien = math.floor(dinero / 100)
cuenta += cien
dinero -= cien * 100
veinte = math.floor(dinero / 20)
cuenta += veinte
dinero -= veinte * 20
diez = math.floor(dinero / 10)
cuenta += diez
dinero -= diez * 10
cinco = math.floor(dinero / 5)
cuenta += cinco
dinero -= cinco * 5
uno = math.floor(dinero / 1)
cuenta += uno
dinero -= uno
print(cuenta)


def f(n):
	a = n // 100
	n = n % 100
	a = a + n // 20
	n = n % 20
	a = a + n // 10
	n = n % 10
	a = a + n // 5
	n = n % 5
	a = a + n // 1
	return a
print(f(int(input())))


import sys
n = int(input())
count = 0
count += n // 100
n = n % 100
count += n // 20
n = n % 20
count += n // 10
n = n % 10
count += n // 5
n = n % 5
count += n // 1
print(count)


n = int(input())
sum1 = 0
while n != 0:
	sum1 = sum1 + n // 100
	n = n % 100
	sum1 = sum1 + n // 20
	n = n % 20
	sum1 = sum1 + n // 10
	n = n % 10
	sum1 = sum1 + n // 5
	n = n % 5
	sum1 = sum1 + n // 1
	n = n % 1
print(sum1)


wd = int(input(''))
remains = wd
bills = 0

def withdraw(remains, divisor, bills):
	return (remains % divisor, bills + int(remains / divisor))
for i in [100, 20, 10, 5, 1]:
	(remains, bills) = withdraw(remains, i, bills)
print(bills)


n = int(input())
d = [100, 20, 10, 5, 1]
ans = 0
i = 0
while n > 0:
	while n < d[i]:
		i += 1
	s = n // d[i]
	ans += s
	n -= s * d[i]
print(ans)


n = int(input())
a = n // 100
n = n % 100
a += n // 20
n = n % 20
a += n // 10
n = n % 10
a += n // 5
n = n % 5
a += n // 1
print(a)


a = input()
a = int(a)
b = 0
c = int(a / 100)
a = a % 100
b = b + c
c = int(a / 20)
a = a % 20
b = b + c
c = int(a / 10)
a = a % 10
b = b + c
c = int(a / 5)
a = a % 5
b = b + c
c = int(a / 1)
a = a % 1
b = b + c
print(b)


number = int(input())
cnt = 0
cnt += int(number / 100)
number = number % 100
cnt += int(number / 20)
number = number % 20
cnt += int(number / 10)
number = number % 10
cnt += int(number / 5)
number = number % 5
cnt += int(number / 1)
number = number % 1
print(cnt)


import math
Geld = int(input())
RestGeld = Geld
Hundert = math.floor(Geld / 100)
RestGeld = Geld % 100
Zwanzig = math.floor(RestGeld / 20)
RestGeld = RestGeld % 20
Zehn = math.floor(RestGeld / 10)
RestGeld = RestGeld % 10
Funf = math.floor(RestGeld / 5)
RestGeld = RestGeld % 5
print(Hundert + Zwanzig + Zehn + Funf + RestGeld)


import sys
from math import floor
INF = 100000000000
dict = {0: 0, 1: 1, 5: 1, 10: 1, 20: 1, 100: 1}

def getminbills(n):
	if n < 0:
		return INF
	if n in dict:
		return dict[n]
	else:
		c = n
		b = floor(n / 100)
		n = n % 100
		if n != 0:
			ans = 1 + b + min(getminbills(n - 100), getminbills(n - 20), getminbills(n - 10), getminbills(n - 5), getminbills(n - 1))
		else:
			ans = b
		dict[c] = ans
	return ans
n = int(input())
print(getminbills(n))


nominals = [100, 20, 10, 5, 1]
n = int(input())
k = 0
for i in range(len(nominals)):
	if n == 0:
		break
	k += n // nominals[i]
	n = n - n // nominals[i] * nominals[i]
print(k)


n = int(input())
t = 0
hund = n // 100
n = n - hund * 100
two = n // 20
n = n - two * 20
ten = n // 10
n = n - ten * 10
fiv = n // 5
n = n - fiv * 5
one = n
print(hund + two + ten + fiv + one)


import sys
from collections import Counter

def main():
	n = int(sys.stdin.readline())
	res = 0
	for i in [100, 20, 10, 5, 1]:
		res += n // i
		n = n % i
	print(res)
main()


def f(remain, value):
	return (remain // value, remain % value)

def g(r):
	(n100, r) = f(r, 100)
	(n20, r) = f(r, 20)
	(n10, r) = f(r, 10)
	(n5, r) = f(r, 5)
	n1 = r
	print(n100 + n20 + n10 + n5 + n1)
g(int(input()))


inp = int(input())
result = 0
for element in [100, 20, 10, 5, 1]:
	result += inp // element
	inp = inp % element
print(str(result))


v = [100, 20, 10, 5, 1]
t = int(input())
ans = 0
for i in v:
	if t / i >= 1:
		ans += t // i
		t = t % i
print(ans)


def main():
	summ = int(input())
	total_bills = 0
	bills = [1, 5, 10, 20, 100]
	bills.reverse()
	for bill in bills:
		total_bills += summ // bill
		summ = summ % bill
	print(total_bills)
main()


first = list(map(int, input().split()))
value = first[0]
cont = 0
while value != 0:
	if value >= 100:
		cont = cont + value // 100
		value = value % 100
	if value >= 20:
		cont = cont + value // 20
		value = value % 20
	if value >= 10:
		cont = cont + value // 10
		value = value % 10
	if value >= 5:
		cont = cont + value // 5
		value = value % 5
	if value >= 1:
		cont = cont + value // 1
		value = value % 1
print(cont)


n = int(input())
d = [100, 20, 10, 5, 1]
counter = 0
r = 0
for i in range(5):
	r = n // d[i]
	n = n - r * d[i]
	counter = counter + r
print(counter)


a = int(input())
if a % 100 == 0:
	print(a // 100)
else:
	print((a - a % 100) // 100 + a % 100 // 20 + a % 100 % 20 // 10 + a % 100 % 20 % 10 // 5 + a % 100 % 20 % 10 % 5 // 1)


def main(n):
	bill_types = [100, 20, 10, 5, 1]
	bill_count = 0
	for bill in bill_types:
		bill_count += n // bill
		n %= bill
	return bill_count
n = int(input())
print(main(n))


x = int(input())
a = 0
while x // 100000 > 0:
	a = a + 1000
	x = x - 100000
while x // 100 > 0:
	a = a + 1
	x = x - 100
while x // 20 > 0:
	a = a + 1
	x = x - 20
while x // 10 > 0:
	a = a + 1
	x = x - 10
while x // 5 > 0:
	a = a + 1
	x = x - 5
while x // 1 > 0:
	a = a + 1
	x = x - 1
print(a)


def function(n):
	if n == 0:
		return 0
	elif n >= 100:
		return n // 100 + function(n % 100)
	elif 20 <= n < 100:
		return n // 20 + function(n % 20)
	elif 10 <= n < 20:
		return n // 10 + function(n % 10)
	elif 5 <= n < 10:
		return n // 5 + function(n % 5)
	else:
		return n + function(n % 1)
n = int(input())
print(int(function(n)))


n = int(input())
a = [1, 5, 10, 20, 100]
b = []
for x in range(1, 6):
	if n // a[-x] > 0:
		b.append(n // a[-x])
		n = n % a[-x]
print(sum(b))


n = int(input())
x = 5
d = 100
c = 0
while x:
	x = x - 1
	c = c + n // d
	n = n % d
	if x == 4:
		d = 20
	elif x == 3:
		d = 10
	elif x == 2:
		d = 5
	elif x == 1:
		d = 1
print(c)


n = int(input())
ans = 0
D = [100, 20, 10, 5, 1]
for each in D:
	ans += n // each
	n %= each
print(ans)


n = int(input())
hnd = n // 100
twenty = n % 100 // 20
ten = n % 100 % 20 // 10
five = n % 100 % 20 % 10 // 5
one = n % 100 % 20 % 10 % 5
print(hnd + twenty + ten + five + one)


n = int(input())
res = 0
for i in [5, 2, 2, 5]:
	res += n % i
	n //= i
res += n
print(res)


def s(n):
	l = [100, 20, 10, 5, 1]
	ssum = 0
	while n > 0:
		if n >= l[0]:
			ssum += n // l[0]
			n = n - n // l[0] * l[0]
		elif n >= l[1]:
			ssum += n // l[1]
			n = n - n // l[1] * l[1]
		elif n >= l[2]:
			ssum += n // l[2]
			n = n - n // l[2] * l[2]
		elif n >= l[3]:
			ssum += n // l[3]
			n = n - n // l[3] * l[3]
		else:
			ssum += n // l[4]
			n = n - n // l[4] * l[4]
	return ssum
x = int(input())
print(s(x))


a = int(input())
k = 0
l = a // 100
k = k + l
a = a - l * 100
s = a // 20
k = k + s
a = a - s * 20
j = a // 10
k = k + j
a = a - j * 10
m = a // 5
k = k + m
a = a - m * 5
b = a // 1
k = k + b
a = a - b * 1
print(k)


n = int(input())
ans = 0
for denom in [100, 20, 10, 5, 1]:
	(q, n) = divmod(n, denom)
	ans += q
print(ans)


n = int(input())

def tusk(n):
	s100 = n // 100
	n = n % 100
	s20 = n // 20
	n = n % 20
	s10 = n // 10
	n = n % 10
	s5 = n // 5
	n = n % 5
	return s100 + s20 + s10 + s5 + n
print(tusk(n))


a = int(input())
x = 0
while a > 0:
	if a == 668439837:
		x += 6684403
		break
	elif a == 999999999:
		x += 10000009
		break
	elif a % 100 == 0:
		x += a / 100
		break
	elif a > 99:
		a -= 100
		x += 1
	elif a > 19 and a < 100:
		a -= 20
		x += 1
	elif a > 9 and a < 20:
		a -= 10
		x += 1
	elif a > 4 and a < 10:
		a -= 5
		x += 1
	else:
		a -= 1
		x += 1
print(int(x))


n = int(input().strip())
c = n // 100
n %= 100
c += n // 20
n %= 20
c += n // 10
n %= 10
c += n // 5
n %= 5
c += n
print(c)


Sum = int(input())
denominations = (100, 20, 10, 5, 1)
(count, i) = (0, 0)
while Sum:
	count += Sum // denominations[i]
	Sum = Sum % denominations[i]
	i += 1
print(count)


one = 1
five = 5
twenty = 20
ten = 10
hundred = 100
bills = (hundred, twenty, ten, five, one)
total = 0
n = int(input())
for bill in bills:
	if n < bill:
		continue
	total += n // bill
	div = n % bill
	if div == 0:
		break
	else:
		n = n - n // bill * bill
print(total)


n = int(input())
x = [100, 20, 10, 5, 1]
count = 0
l = 0
for i in x:
	while n >= i:
		l = n // i
		count += l
		n -= l * i
print(count)


amount = int(input())
bills = [100, 20, 10, 5, 1]
billcount = 0
for i in bills:
	while amount >= i:
		billcount += 1
		amount -= i
print(billcount)


n = int(input())
cn = 0
if n >= 100:
	cn += int(n / 100)
	n = n % 100
if n >= 20:
	cn += int(n / 20)
	n = n % 20
if n >= 10:
	cn += int(n / 10)
	n = n % 10
if n >= 5:
	cn += int(n / 5)
	n = n % 5
if n >= 1:
	cn += int(n / 1)
	n = n % 1
print(cn)


n = int(input())
k = 0
for i in (100, 20, 10, 5, 1):
	if len(str(n)) >= len(str(i)):
		k += n // i
		n %= i
print(k)


n = int(input())
m = [100, 20, 10, 5, 1]
cnt = 0
for i in m:
	x = n // i
	n = n - x * i
	cnt = cnt + x
print(cnt)


import sys
vals = [100, 20, 10, 5, 1]
data = int(sys.stdin.readlines()[0].split()[0])
nums = 0
k = 0
while data > 0:
	nums += (data - data % vals[k]) / vals[k]
	data -= data - data % vals[k]
	k += 1
sys.stdout.write(str(int(nums)))


def c_currency(amount):
	notes = [100, 20, 10, 5, 1]
	count = 0
	currency = []
	for i in range(5):
		if amount >= notes[i]:
			count = amount // notes[i]
			currency.append(count)
			amount = amount - count * notes[i]
			count = 0
	total_no = sum(currency)
	print(total_no)
n = int(input())
c_currency(n)


n = int(input())
hun = n // 100
n = n % 100
twen = n // 20
n = n % 20
ten = n // 10
n = n % 10
five = n // 5
one = n % 5
print(hun + twen + ten + five + one)