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 ≤ n ≤ 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.
import sys
import math

# Constants
mod = 998244353

# Program Settings
cases = False


# Functions Settings
dynamic_factorial = False



# Pre-defined function
# Begin

# Testcase handler
def main(test_case = False):
    n = int(input()) if test_case else 1
    for _ in range(n):
        test()

# Binary method of power
def fast_pow(a:int, b:int):
    res = 1
    while b > 0:
        if b & 1:
            res *= a
        a *= a
        b >>= 1
    return res

# Combination of 2
def c2(n):
    return n * (n-1) // 2

# Get the list form of input
def get():
    return list(map(int, input().split()))

# Number of 1s in binary form
def bits(n: int):
    return list(bin(n)).count('1')

# For interactive problems
def flush():
    sys.stdout.flush()

# Print array and split it with space
def parr(arr):
    print(*arr, sep=' ')

# GCD (int a, int b)
# Return: value of GCD(a, b)
def gcd(a, b):
    while b:
        if b % a == 0:
            break
        tmp = a
        a = b % a
        b = tmp
    return a

# Extended GCD (int a, int b)
# Return: array of [GCD(a, b), [x0, y0]]
# Where a * x0 + b * y0 = 1
# If GCD(a, b) != 1 then return False
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]]

# Get all different values of array a with their count
def get_set(a):
    res = {}
    for x in a:
        if x in res:
            res[x] += 1
        else:
            res[x] = 1
    return res

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

# Sum of array
def sum_of(a):
    res = 0
    for x in a:
        res = (res + x) % mod
    return res

# Prod of array
def prod_of(a):
    res = 1
    for x in a:
        res = (res * x) % mod
    return res

# End

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)