





'''simple docstring'''

def 	_snake_case						(      ):
  """simple docstring"""







  return 1






def 	_snake_case						(      A_       :    Tuple   ):
  """simple docstring"""







  return 0 if x < 0 else two_pence(x - 2   ) + one_pence()






def 	_snake_case						(      A_       :    Dict   ):
  """simple docstring"""







  return 0 if x < 0 else five_pence(x - 5   ) + two_pence(_lowercase   )






def 	_snake_case						(      A_       :    Optional[Any]   ):
  """simple docstring"""







  return 0 if x < 0 else ten_pence(x - 10   ) + five_pence(_lowercase   )






def 	_snake_case						(      A_       :    List[str]   ):
  """simple docstring"""







  return 0 if x < 0 else twenty_pence(x - 20   ) + ten_pence(_lowercase   )






def 	_snake_case						(      A_       :    List[Any]   ):
  """simple docstring"""







  return 0 if x < 0 else fifty_pence(x - 50   ) + twenty_pence(_lowercase   )






def 	_snake_case						(      A_       :    Tuple   ):
  """simple docstring"""







  return 0 if x < 0 else one_pound(x - 100   ) + fifty_pence(_lowercase   )






def 	_snake_case						(      A_       :    Optional[Any]   ):
  """simple docstring"""







  return 0 if x < 0 else two_pound(x - 200   ) + one_pound(_lowercase   )






def 	_snake_case						(      A_       :    Optional[int] = 200   ):
  """simple docstring"""







  return two_pound(_lowercase   )


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




'''simple docstring'''

from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_torch_available,
)


__snake_case:  Dict								=			{"configuration_encoder_decoder": ["EncoderDecoderConfig"]}

try:
    if not is_torch_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    __snake_case:  List[str]								=			["EncoderDecoderModel"]

try:
    if not is_tf_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    __snake_case:  Any								=			["TFEncoderDecoderModel"]

try:
    if not is_flax_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    __snake_case:  List[str]								=			["FlaxEncoderDecoderModel"]

if TYPE_CHECKING:
    from .configuration_encoder_decoder import EncoderDecoderConfig

    try:
        if not is_torch_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_encoder_decoder import EncoderDecoderModel

    try:
        if not is_tf_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_tf_encoder_decoder import TFEncoderDecoderModel

    try:
        if not is_flax_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_flax_encoder_decoder import FlaxEncoderDecoderModel

else:
    import sys

    __snake_case:  Tuple								=			_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)


