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 java.io.*;
import java.util.*;

import javafx.util.Pair;
 
public class Solution {
	public final static int MOD = 1000000007;
	public final static int dx[] = {0,0,1,-1};
	public final static int dy[] = {1,-1,0,0};
	public static void main(String[] args) throws IOException {
		InputReader scan = new InputReader(System.in);
	   	PrintWriter pw = new PrintWriter(System.out);
	   	StringBuilder sb = new StringBuilder();
	   	int n = scan.nextInt();
	   	int arr[] = {100, 20, 10, 5, 1};
	   	int count = 0;
	   	for(int i=0;i<5;i++)
	   	{
	   		count+=(n/arr[i]);
	   		n%=arr[i];
	   	}
	   	pw.println(count);
	   	pw.close(); 
	}
	public static boolean possible(long n,long k)
	{
		long temp = 0;
		long copy = n;
		while(n>0)
		{
			if(k<=n)
			{
				n-=k;
				temp+=k;
			}
			else
			{
				temp+=n;
				n = 0;
			}
			n-=(n/10);
		}
		if(temp*2>=copy)
			return true;
		return false;
	}
	public static int[][] graph(int from[],int to[],int m,int n)
	{
		int[][] g = new int[n+1][];
		int count[] = new int[n+1];
		Arrays.fill(count, 0);
		for(int i=0;i<m;i++)
		{
			count[from[i]]++;
			count[to[i]]++;
		}
		for(int i=0;i<n+1;i++)
			g[i] = new int[count[i]];
		Arrays.fill(count, 0);
		for(int i=0;i<m;i++)
		{
			g[from[i]][count[from[i]]++] = to[i];
			g[to[i]][count[to[i]]++] = from[i];
		}
		return g;
	}
	public static int query(int tree[],int node,int l,int r,int start,int end)
	{
		if(r<start || l>end)
			return -1;
		if(l<=start && end<=r)
			return tree[node];
		int mid = (start+end)/2;
		int ans1 = query(tree,2*node+1,l,r,start,mid);
		int ans2 = query(tree,2*node+2,l,r,mid+1,end);
		return Math.max(ans1, ans2);
	}
	public static void buildTree(ArrayList<Integer> len,int tree[],int node,int start,int end)
	{
		if(start==end)
		{
			tree[node] = len.get(start);
			return;
		}
		int mid = (start+end)/2;
		buildTree(len,tree,2*node+1,start,mid);
		buildTree(len,tree,2*node+2,mid+1,end);
		tree[node] = Math.max(tree[2*node+1], tree[2*node+2]);
	}
	public static void update(int arr[],int tree[],int node,int inx,int val,int start,int end)
	{ 
		if(start==end)
		{
			tree[node] = val;
			arr[inx] = val;
			return;
		}
		int mid = (start+end)/2;
		if(inx<=mid)
			update(arr,tree,2*node,inx,val,start,mid);
		else
			update(arr,tree,2*node+1,inx,val,mid+1,end);
		tree[node] = tree[2*node]+tree[2*node+1];
	}
	public static long phi(int n,int spf[])
	{
		ArrayList<Integer> f = new ArrayList<>();
		factors(n,spf,f);
		long ans = n;
		for(int i=0;i<f.size();i++)
			ans-=(ans/f.get(i));
		return ans;
	}
	public static void factors(int n,int spf[],ArrayList<Integer> factors)
	{
		int pre = 0;
		while(n!=1)
		{
			int temp = spf[n];
			if(temp!=pre)
			{
				factors.add(temp);
				pre = temp;
			}
			n/=temp;
		}
	}
	public static boolean isPrime(long n)
	{
		if(n==0 || n==1)
			return false;
		int limit = (int)Math.sqrt(n);
		for(int i=2;i<=limit;i++)
		{
			if(n%i==0)
				return false;
		}
		return true;
	}
	public static int binarySearch(ArrayList<Integer> arr,int key)
	{
		int l = 0, r = arr.size()-1;
		while(l<=r)
		{
			int mid = (l+r)/2;
			if(arr.get(mid)==key)
			{
				r = mid;
				break;
			}
			if(arr.get(mid)>key)
				r = mid-1; 
			else
				l = mid+1;
		}
		return r;
	}
	public static int find(int x,int parent[])
	{
		if(parent[x]!=x)
			parent[x] = find(parent[x],parent);
		return parent[x];
	}
	public static void union(int parent[],int x,int y)
	{
		int xParent = find(x,parent);
		int yParent = find(y,parent);
		parent[xParent] = yParent;
	}
	public static void merge(int arr[],int start,int mid,int end)
	{
		int l = start, r = mid+1;
		int temp[] = new int[end-start+1];
		int k = 0;
		for(int i=start;i<=end;i++)
		{
			if(l>mid)
				temp[k++] = arr[r++];
			else if(r>end)
				temp[k++] = arr[l++];
			else if(arr[l]<=arr[r])
				temp[k++] = arr[l++];
			else
				temp[k++] = arr[r++];
		}
		for(int i=0;i<k;i++)
			arr[start++] = temp[i];
	}
	public static void mergeSort(int arr[],int l,int r)
	{
		if(l<r){
			int mid = (l+r)/2;
			mergeSort(arr,l,mid);
			mergeSort(arr,mid+1,r);
			merge(arr,l,mid,r);
		}
	}
	public static void sieve(int spf[],int n)
	{
		for(int i=0;i<n;i++)
			spf[i] = i;
		for(int i=2;i<n;i+=2)
			spf[i] = 2;
		for(int i=3;i*i<n;i++)
		{
			if(spf[i]==i)
			{
				for(int j=i*i;j<n;j+=i)
					if(spf[j]==j)
						spf[j] = i;
			}
		}
	}
	public static long pow(long a,long b,int m)
	{
		long result = 1;
		while(b>0)
		{
			if(b%2==1)
				result = ((result%m)*(a%m))%m;
			a = ((a%m)*(a%m))%m;
			b/=2;
		}
		return result;
	}
	public static long mulinv(long a,long m)
	{
		long arr[] = new long[2];
		long gcd = gcdExtended(a,m,arr);
		if(gcd==1)
			return (arr[0]%m+m)%m;
		else
			return Integer.MAX_VALUE;
	}
	public static long gcdExtended(long a,long b,long arr[])
	{
		if (a == 0)
	    {
	        arr[0] = 0;
	        arr[1] = 1;
	        return b;
	    }
	    long gcd = gcdExtended(b%a, a, arr);
	    long temp = arr[0];
	    arr[0] = arr[1] - (b/a) * arr[0];
	    arr[1] = temp;
	    return gcd;
	}
	public static long kadane(int items[])
	{
		int n = items.length;
		long max = (long)items[0];
		long curr_max = (long)items[0];
		for(int i=1;i<n;i++)
		{
			curr_max = Math.max((long)curr_max+items[i], items[i]);
			max = Math.max(max, curr_max);
		}
		return max;
	}
	public static int gcd(int a,int b)
	{
		if(b==0)
			return a;
		return gcd(b,a%b);
	}
	public static int LCS(String s1,String s2) //Longest common subsequence
	{
		int n = s1.length();
		int m = s2.length();
		int lcs[][] = new int[n+1][m+1];
		for(int i=0;i<=n;i++)
		{
			for(int j=0;j<=m;j++)
			{
				if(i==0 || j==0)
					lcs[i][j] = 0;
				else if(s1.charAt(i-1)==s2.charAt(j-1))
					lcs[i][j] = lcs[i-1][j-1] + 1;
				else
					lcs[i][j] = Math.max(lcs[i][j-1], lcs[i-1][j]);
			}
		}
		return lcs[n][m];
	}
	static class InputReader {
		 
		private final InputStream stream;
		private final byte[] buf = new byte[8192];
		private int curChar, snumChars;
		private SpaceCharFilter filter;
 
		public InputReader(InputStream stream) {
			this.stream = stream;
		}
 
		public int snext() {
			if (snumChars == -1)
				throw new InputMismatchException();
			if (curChar >= snumChars) {
				curChar = 0;
				try {
					snumChars = stream.read(buf);
				} catch (IOException e) {
					throw new InputMismatchException();
				}
				if (snumChars <= 0)
					return -1;
			}
			return buf[curChar++];
		}
 
		public int nextInt() {
			int c = snext();
			while (isSpaceChar(c))
				c = snext();
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = snext();
			}
			int res = 0;
			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = snext();
			} while (!isSpaceChar(c));
			return res * sgn;
		}
 
		public long nextLong() {
			int c = snext();
			while (isSpaceChar(c))
				c = snext();
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = snext();
			}
			long res = 0;
			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = snext();
			} while (!isSpaceChar(c));
			return res * sgn;
		}
 
		public int[] nextIntArray(int n) {
			int a[] = new int[n];
			for (int i = 0; i < n; i++)
				a[i] = nextInt();
			return a;
		}
 
		public String readString() {
			int c = snext();
			while (isSpaceChar(c))
				c = snext();
			StringBuilder res = new StringBuilder();
			do {
				res.appendCodePoint(c);
				c = snext();
			} while (!isSpaceChar(c));
			return res.toString();
		}
 
		public boolean isSpaceChar(int c) {
			if (filter != null)
				return filter.isSpaceChar(c);
			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
		}
 
		public interface SpaceCharFilter {
			public boolean isSpaceChar(int ch);
		}
	}
}

class pair extends Pair<Integer, Integer>{
	pair(int l,int r)
	{
		super(l,r);
	}
}