

"""simple docstring"""




import dataclasses
import json
import warnings
from dataclasses import dataclass, field
from time import time
from typing import List

from ..utils import logging


SCREAMING_SNAKE_CASE_     :			Tuple	  =							logging.get_logger(__name__)



def 	UpperCAmelCase__   (				A__=None	,    A__=None   )      ->      Optional[int]:




   """simple docstring"""
   return field(default_factory=lambda: default	,    metadata=__UpperCamelCase   )


@dataclass
class 		_A       :
      __a								=	list_field(
          default=[]				,       metadata={
              'help': (
                  'Model checkpoints to be provided to the AutoModel classes. Leave blank to benchmark the base version'
                  ' of all available models'
              )
          }				,       )

      __a								=	list_field(
          default=[8]				,       metadata={'help': 'List of batch sizes for which memory and time performance will be evaluated'}					)

      __a								=	list_field(
          default=[8, 32, 128, 512]				,       metadata={'help': 'List of sequence lengths for which memory and time performance will be evaluated'}				,       )

      __a								=	field(
          default=SCREAMING_SNAKE_CASE__				,       metadata={'help': 'Whether to benchmark inference of model. Inference can be disabled via --no-inference.'}				,       )
      __a								=	field(
          default=SCREAMING_SNAKE_CASE__				,       metadata={'help': 'Whether to run on available cuda devices. Cuda can be disabled via --no-cuda.'}				,       )
      __a								=	field(
          default=SCREAMING_SNAKE_CASE__				,       metadata={'help': 'Whether to run on available tpu devices. TPU can be disabled via --no-tpu.'}					)
      __a								=	field(default=SCREAMING_SNAKE_CASE__				,       metadata={'help': 'Use FP16 to accelerate inference.'}					)
      __a								=	field(default=SCREAMING_SNAKE_CASE__				,       metadata={'help': 'Benchmark training of model'}					)
      __a								=	field(default=SCREAMING_SNAKE_CASE__				,       metadata={'help': 'Verbose memory tracing'}					)
      __a								=	field(
          default=SCREAMING_SNAKE_CASE__				,       metadata={'help': 'Whether to perform speed measurements. Speed measurements can be disabled via --no-speed.'}				,       )
      __a								=	field(
          default=SCREAMING_SNAKE_CASE__				,       metadata={
              'help': 'Whether to perform memory measurements. Memory measurements can be disabled via --no-memory'
          }				,       )
      __a								=	field(default=SCREAMING_SNAKE_CASE__				,       metadata={'help': 'Trace memory line by line'}					)
      __a								=	field(default=SCREAMING_SNAKE_CASE__				,       metadata={'help': 'Save result to a CSV file'}					)
      __a								=	field(default=SCREAMING_SNAKE_CASE__				,       metadata={'help': 'Save all print statements in a log file'}					)
      __a								=	field(default=SCREAMING_SNAKE_CASE__				,       metadata={'help': 'Whether to print environment information'}					)
      __a								=	field(
          default=SCREAMING_SNAKE_CASE__				,       metadata={
              'help': (
                  'Whether to use multiprocessing for memory and speed measurement. It is highly recommended to use'
                  ' multiprocessing for accurate CPU and GPU memory measurements. This option should only be disabled'
                  ' for debugging / testing and on TPU.'
              )
          }				,       )
      __a								=	field(
          default=F"""inference_time_{round(time()					)}.csv"""				,       metadata={'help': 'CSV filename used if saving time results to csv.'}				,       )
      __a								=	field(
          default=F"""inference_memory_{round(time()					)}.csv"""				,       metadata={'help': 'CSV filename used if saving memory results to csv.'}				,       )
      __a								=	field(
          default=F"""train_time_{round(time()					)}.csv"""				,       metadata={'help': 'CSV filename used if saving time results to csv for training.'}				,       )
      __a								=	field(
          default=F"""train_memory_{round(time()					)}.csv"""				,       metadata={'help': 'CSV filename used if saving memory results to csv for training.'}				,       )
      __a								=	field(
          default=F"""env_info_{round(time()					)}.csv"""				,       metadata={'help': 'CSV filename used if saving environment information.'}				,       )
      __a								=	field(
          default=F"""log_{round(time()					)}.csv"""				,       metadata={'help': 'Log filename used if print statements are saved in log.'}				,       )
      __a								=	field(default=3				,       metadata={'help': 'Times an experiment will be run.'}					)
      __a								=	field(
          default=SCREAMING_SNAKE_CASE__				,       metadata={
              'help': (
                  'Instead of loading the model as defined in `config.architectures` if exists, just load the pretrain'
                  ' model weights.'
              )
          }				,       )





      def 					_lowerCamelCase  (  self		)   ->					Tuple:
         warnings.warn(
             f'The class {self.__class__} is deprecated. Hugging Face Benchmarking utils'
             " are deprecated in general and it is advised to use external Benchmarking libraries "
             " to benchmark Transformer models."    ,						_lowercase    ,						)





      def 					_lowerCamelCase  (  self		)   ->					Tuple:
         return json.dumps(dataclasses.asdict(self		)    ,						indent=2		)





      @property
      def 					_lowerCamelCase  (  self		)   ->					List[str]:

         if len(self.models		) <= 0:
            raise ValueError(
                "Please make sure you provide at least one model name / model identifier, *e.g.* `--models"
                " bert-base-cased` or `args.models = ['bert-base-cased']."		)
         return self.models





      @property
      def 					_lowerCamelCase  (  self		)   ->					Optional[Any]:

         if not self.multi_process:
            return False
         elif self.is_tpu:
            logger.info("Multiprocessing is currently not possible on TPU."		)
            return False
         else:
            return True







"""simple docstring"""




def 	UpperCAmelCase__   (				)      ->      int:




   """simple docstring"""
   return 1



def 	UpperCAmelCase__   (				A__   )      ->      int:




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



def 	UpperCAmelCase__   (				A__   )      ->      int:




   """simple docstring"""
   return 0 if x < 0 else five_pence(x - 5   ) + two_pence(A__   )



def 	UpperCAmelCase__   (				A__   )      ->      int:




   """simple docstring"""
   return 0 if x < 0 else ten_pence(x - 10   ) + five_pence(A__   )



def 	UpperCAmelCase__   (				A__   )      ->      int:




   """simple docstring"""
   return 0 if x < 0 else twenty_pence(x - 20   ) + ten_pence(A__   )



def 	UpperCAmelCase__   (				A__   )      ->      int:




   """simple docstring"""
   return 0 if x < 0 else fifty_pence(x - 50   ) + twenty_pence(A__   )



def 	UpperCAmelCase__   (				A__   )      ->      int:




   """simple docstring"""
   return 0 if x < 0 else one_pound(x - 100   ) + fifty_pence(A__   )



def 	UpperCAmelCase__   (				A__   )      ->      int:




   """simple docstring"""
   return 0 if x < 0 else two_pound(x - 200   ) + one_pound(A__   )



def 	UpperCAmelCase__   (				A__ = 200   )      ->      int:




   """simple docstring"""
   return two_pound(A__   )


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




