






import functools
import logging
import os
import sys
import threading
from logging import (
    CRITICAL,  # NOQA
    DEBUG,  # NOQA
    ERROR,  # NOQA
    FATAL,  # NOQA
    INFO,  # NOQA
    NOTSET,  # NOQA
    WARN,  # NOQA
    WARNING,  # NOQA
)
from typing import Optional

import huggingface_hub.utils as hf_hub_utils
from tqdm import auto as tqdm_lib


UpperCamelCase							=threading.Lock()
UpperCamelCase							=None

UpperCamelCase							={
    'debug': logging.DEBUG,
    'info': logging.INFO,
    'warning': logging.WARNING,
    'error': logging.ERROR,
    'critical': logging.CRITICAL,
}

UpperCamelCase							=logging.WARNING

UpperCamelCase							=True



def 							snake_case					(     )       ->				List[Any]:





      """simple docstring"""

      UpperCamelCase_				:   Optional[int]					    =							os.getenv("""TRANSFORMERS_VERBOSITY"""    ,   _A	)
      if env_level_str:
            if env_level_str in log_levels:
                  return log_levels[env_level_str]
            else:
                  logging.getLogger().warning(
                      f"Unknown option TRANSFORMERS_VERBOSITY={env_level_str}, "
                      f"has to be one of: { ', '.join(log_levels.keys()	) }"	)
      return _default_log_level



def 							snake_case					(     )       ->				str:





      """simple docstring"""

      return __name__.split("""."""	)[0]



def 							snake_case					(     )       ->				logging.Logger:





      """simple docstring"""

      return logging.getLogger(_get_library_name()	)



def 							snake_case					(     )       ->				None:





      """simple docstring"""

      global _default_handler

      with _lock:
            if _default_handler:
                  # This library has already configured the library root logger.
                  return
            UpperCamelCase_				:   Dict					    =							logging.StreamHandler()  # Set sys.stderr as stream.
            UpperCamelCase_				:   Optional[int]					    =							sys.stderr.flush

            # Apply our default configuration to the library root logger.
            UpperCamelCase_				:   Dict					    =							_get_library_root_logger()
            library_root_logger.addHandler(_default_handler	)
            library_root_logger.setLevel(_get_default_logging_level()	)
            UpperCamelCase_				:   str					    =							False



def 							snake_case					(     )       ->				None:





      """simple docstring"""

      global _default_handler

      with _lock:
            if not _default_handler:
                  return

            UpperCamelCase_				:   Dict					    =							_get_library_root_logger()
            library_root_logger.removeHandler(_default_handler	)
            library_root_logger.setLevel(logging.NOTSET	)
            UpperCamelCase_				:   Tuple					    =							None



def 							snake_case					(     )       ->				Optional[int]:





      """simple docstring"""

      return log_levels



def 							snake_case					(     a_							: Optional[str] = None	)       ->				logging.Logger:





      """simple docstring"""

      if name is None:
            UpperCamelCase_				:   Any					    =							_get_library_name()

      _configure_library_root_logger()
      return logging.getLogger(_A	)



def 							snake_case					(     )       ->				int:





      """simple docstring"""

      _configure_library_root_logger()
      return _get_library_root_logger().getEffectiveLevel()



def 							snake_case					(     a_							: int	)       ->				None:





      """simple docstring"""

      _configure_library_root_logger()
      _get_library_root_logger().setLevel(_A	)



def 							snake_case					(     )       ->				int:





      """simple docstring"""

      return set_verbosity(_A	)



def 							snake_case					(     )       ->				List[Any]:





      """simple docstring"""

      return set_verbosity(_A	)



def 							snake_case					(     )       ->				Tuple:





      """simple docstring"""

      return set_verbosity(_A	)



def 							snake_case					(     )       ->				List[Any]:





      """simple docstring"""

      return set_verbosity(_A	)



def 							snake_case					(     )       ->				None:





      """simple docstring"""

      _configure_library_root_logger()

      assert _default_handler is not None
      _get_library_root_logger().removeHandler(_default_handler	)



def 							snake_case					(     )       ->				None:





      """simple docstring"""

      _configure_library_root_logger()

      assert _default_handler is not None
      _get_library_root_logger().addHandler(_default_handler	)



def 							snake_case					(     a_							: logging.Handler	)       ->				None:





      """simple docstring"""

      _configure_library_root_logger()

      assert handler is not None
      _get_library_root_logger().addHandler(_A	)



def 							snake_case					(     a_							: logging.Handler	)       ->				None:





      """simple docstring"""

      _configure_library_root_logger()

      assert handler is not None and handler not in _get_library_root_logger().handlers
      _get_library_root_logger().removeHandler(_A	)



def 							snake_case					(     )       ->				None:





      """simple docstring"""

      _configure_library_root_logger()
      UpperCamelCase_				:   Union[str, Any]					    =							False



def 							snake_case					(     )       ->				None:





      """simple docstring"""

      _configure_library_root_logger()
      UpperCamelCase_				:   Union[str, Any]					    =							True



def 							snake_case					(     )       ->				None:





      """simple docstring"""

      UpperCamelCase_				:   str					    =							_get_library_root_logger().handlers

      for handler in handlers:
            UpperCamelCase_				:   List[str]					    =							logging.Formatter("""[%(levelname)s|%(filename)s:%(lineno)s] %(asctime)s >> %(message)s"""	)
            handler.setFormatter(_A	)



def 							snake_case					(     )       ->				None:





      """simple docstring"""

      UpperCamelCase_				:   Any					    =							_get_library_root_logger().handlers

      for handler in handlers:
            handler.setFormatter(_A	)



def 							snake_case					(     self							: List[str]    ,   *a_							: str    ,   **a_							: Any	)       ->				Union[str, Any]:





      """simple docstring"""

      UpperCamelCase_				:   Optional[Any]					    =							os.getenv("""TRANSFORMERS_NO_ADVISORY_WARNINGS"""    ,   _A	)
      if no_advisory_warnings:
            return
      self.warning(*_A    ,   **_A	)


UpperCamelCase							=warning_advice



@functools.lru_cache(_A	)
def 							snake_case					(     self							: List[Any]    ,   *a_							: int    ,   **a_							: Tuple	)       ->				str:





      """simple docstring"""

      self.warning(*_A    ,   **_A	)


UpperCamelCase							=warning_once




class     A    :






 """simple docstring"""





 def __init__(							self			,     *__lowerCAmelCase			,     **__lowerCAmelCase ):  # pylint: disable=unused-argument
       UpperCamelCase_				:   Any					    =							args[0] if args else None
 def __iter__(							self ):
       return iter(self._iterator )
 def __getattr__(							self			,     __lowerCAmelCase ):

       def empty_fn(*__lowerCAmelCase			,     **__lowerCAmelCase ):  # pylint: disable=unused-argument
             return

       return empty_fn
 def __enter__(							self ):
       return self





 def __exit__(							self			,     __lowerCAmelCase			,     __lowerCAmelCase			,     __lowerCAmelCase ):
       return






class     A    :






 """simple docstring"""





 def __call__(							self			,     *__lowerCAmelCase			,     **__lowerCAmelCase ):
       if _tqdm_active:
             return tqdm_lib.tqdm(*_SCREAMING_SNAKE_CASE			,     **_SCREAMING_SNAKE_CASE )
       else:
             return EmptyTqdm(*_SCREAMING_SNAKE_CASE			,     **_SCREAMING_SNAKE_CASE )
 def   _UpperCAmelCase       (							self			,     *__lowerCAmelCase			,     **__lowerCAmelCase ):
       UpperCamelCase_				:   List[Any]					    =							None
       if _tqdm_active:
             return tqdm_lib.tqdm.set_lock(*_SCREAMING_SNAKE_CASE			,     **_SCREAMING_SNAKE_CASE )





 def   _UpperCAmelCase       (							self ):
       if _tqdm_active:
             return tqdm_lib.tqdm.get_lock()






UpperCamelCase							=_tqdm_cls()



def 							snake_case					(     )       ->				bool:





      """simple docstring"""

      global _tqdm_active
      return bool(_tqdm_active	)



def 							snake_case					(     )       ->				Any:





      """simple docstring"""

      global _tqdm_active
      UpperCamelCase_				:   List[str]					    =							True
      hf_hub_utils.enable_progress_bars()



def 							snake_case					(     )       ->				Tuple:





      """simple docstring"""

      global _tqdm_active
      UpperCamelCase_				:   Any					    =							False
      hf_hub_utils.disable_progress_bars()














'''simple docstring'''

def 							snake_case					(     )       ->				int:





      """simple docstring"""

      return 1



def 							snake_case					(     a_							: int	)       ->				int:





      """simple docstring"""

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



def 							snake_case					(     a_							: int	)       ->				int:





      """simple docstring"""

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



def 							snake_case					(     a_							: int	)       ->				int:





      """simple docstring"""

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



def 							snake_case					(     a_							: int	)       ->				int:





      """simple docstring"""

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



def 							snake_case					(     a_							: int	)       ->				int:





      """simple docstring"""

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



def 							snake_case					(     a_							: int	)       ->				int:





      """simple docstring"""

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



def 							snake_case					(     a_							: int	)       ->				int:





      """simple docstring"""

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



def 							snake_case					(     a_							: int = 200	)       ->				int:





      """simple docstring"""

      return two_pound(a_	)


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






