





'''simple docstring'''




def 	__lowerCamelCase			(      )		->  int:
   return 1





def 	__lowerCamelCase			(      __lowerCAmelCase       :							int		)		->  int:
   return 0 if x < 0 else two_pence(x - 2		) + one_pence()





def 	__lowerCamelCase			(      __lowerCAmelCase       :							int		)		->  int:
   return 0 if x < 0 else five_pence(x - 5		) + two_pence(__lowerCAmelCase		)





def 	__lowerCamelCase			(      __lowerCAmelCase       :							int		)		->  int:
   return 0 if x < 0 else ten_pence(x - 10		) + five_pence(__lowerCAmelCase		)





def 	__lowerCamelCase			(      __lowerCAmelCase       :							int		)		->  int:
   return 0 if x < 0 else twenty_pence(x - 20		) + ten_pence(__lowerCAmelCase		)





def 	__lowerCamelCase			(      __lowerCAmelCase       :							int		)		->  int:
   return 0 if x < 0 else fifty_pence(x - 50		) + twenty_pence(__lowerCAmelCase		)





def 	__lowerCamelCase			(      __lowerCAmelCase       :							int		)		->  int:
   return 0 if x < 0 else one_pound(x - 1_00		) + fifty_pence(__lowerCAmelCase		)





def 	__lowerCamelCase			(      __lowerCAmelCase       :							int		)		->  int:
   return 0 if x < 0 else two_pound(x - 2_00		) + one_pound(__lowerCAmelCase		)





def 	__lowerCamelCase			(      __lowerCAmelCase       :							int = 2_00		)		->  int:
   return two_pound(__lowerCAmelCase		)


if __name__ == "__main__":
 print(solution(int(input().strip())))








'''simple docstring'''




from __future__ import annotations

import os
from collections.abc import Mapping

_SCREAMING_SNAKE_CASE							     =			tuple[int, int]
class 			_lowerCAmelCase		:






     """simple docstring"""






     def __init__(   self							:			List[Any]   ,       __snake_case							:			set[int]   ,       __snake_case							:			Mapping[EdgeT, int]						)->	None:
        snake_case 						=   vertices
        snake_case 						=   {
            (min(__snake_case						), max(__snake_case						)): weight for edge, weight in edges.items()
        }



     def      lowerCAmelCase			(   self							:			Optional[Any]   ,       __snake_case							:			EdgeT   ,       __snake_case							:			int						)->	None:
        self.vertices.add(edge[0]						)
        self.vertices.add(edge[1]						)
        snake_case 						=   weight



     def      lowerCAmelCase			(   self							:			str						)->	Graph:
        snake_case 						=   Graph({min(self.vertices						)}   ,       {}						)
        snake_case 						=   42
        snake_case 						=   42
        snake_case 						=   42
        snake_case 						=   42

        while len(subgraph.vertices						) < len(self.vertices						):
           snake_case 						=   max(self.edges.values()						) + 1
           for edge, weight in self.edges.items():
              if (edge[0] in subgraph.vertices) ^ (edge[1] in subgraph.vertices):
                 if weight < min_weight:
                    snake_case 						=   edge
                    snake_case 						=   weight

           subgraph.add_edge(__snake_case   ,       __snake_case						)

        return subgraph





def 	__lowerCamelCase			(      __lowerCAmelCase       :							str = "p107_network.txt"		)		->  int:
   snake_case 						=   os.path.abspath(os.path.dirname(__lowerCAmelCase		)		)
   snake_case 						=   os.path.join(__lowerCAmelCase      ,    __lowerCAmelCase		)
   snake_case 						=   {}
   snake_case 						=   42
   snake_case 						=   42
   snake_case 						=   42

   with open(__lowerCAmelCase		) as f:
      snake_case 						=   f.read().strip().split("""\n"""		)

   snake_case 						=   [line.split(""","""		) for line in data]

   for edgea in range(1      ,    len(__lowerCAmelCase		)		):
      for edgea in range(__lowerCAmelCase		):
         if adjaceny_matrix[edgea][edgea] != "-":
            snake_case 						=   int(adjaceny_matrix[edgea][edgea]		)

   snake_case 						=   Graph(set(range(len(__lowerCAmelCase		)		)		)      ,    __lowerCAmelCase		)

   snake_case 						=   graph.prims_algorithm()

   snake_case 						=   sum(graph.edges.values()		)
   snake_case 						=   sum(subgraph.edges.values()		)

   return initial_total - optimal_total


if __name__ == "__main__":
 print(F"""{solution() = }""")

