





'''simple docstring'''






import json
from typing import List, Optional, Tuple

from tokenizers import pre_tokenizers, processors

from ...tokenization_utils_base import AddedToken, BatchEncoding
from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging
from .tokenization_roberta import RobertaTokenizer


__UpperCamelCase					    =	logging.get_logger(__name__)

__UpperCamelCase					    =	{"vocab_file": "vocab.json", "merges_file": "merges.txt", "tokenizer_file": "tokenizer.json"}

__UpperCamelCase					    =	{
    "vocab_file": {
        "roberta-base": "https://huggingface.co/roberta-base/resolve/main/vocab.json",
        "roberta-large": "https://huggingface.co/roberta-large/resolve/main/vocab.json",
        "roberta-large-mnli": "https://huggingface.co/roberta-large-mnli/resolve/main/vocab.json",
        "distilroberta-base": "https://huggingface.co/distilroberta-base/resolve/main/vocab.json",
        "roberta-base-openai-detector": "https://huggingface.co/roberta-base-openai-detector/resolve/main/vocab.json",
        "roberta-large-openai-detector": (
            "https://huggingface.co/roberta-large-openai-detector/resolve/main/vocab.json"
        ),
    },
    "merges_file": {
        "roberta-base": "https://huggingface.co/roberta-base/resolve/main/merges.txt",
        "roberta-large": "https://huggingface.co/roberta-large/resolve/main/merges.txt",
        "roberta-large-mnli": "https://huggingface.co/roberta-large-mnli/resolve/main/merges.txt",
        "distilroberta-base": "https://huggingface.co/distilroberta-base/resolve/main/merges.txt",
        "roberta-base-openai-detector": "https://huggingface.co/roberta-base-openai-detector/resolve/main/merges.txt",
        "roberta-large-openai-detector": (
            "https://huggingface.co/roberta-large-openai-detector/resolve/main/merges.txt"
        ),
    },
    "tokenizer_file": {
        "roberta-base": "https://huggingface.co/roberta-base/resolve/main/tokenizer.json",
        "roberta-large": "https://huggingface.co/roberta-large/resolve/main/tokenizer.json",
        "roberta-large-mnli": "https://huggingface.co/roberta-large-mnli/resolve/main/tokenizer.json",
        "distilroberta-base": "https://huggingface.co/distilroberta-base/resolve/main/tokenizer.json",
        "roberta-base-openai-detector": (
            "https://huggingface.co/roberta-base-openai-detector/resolve/main/tokenizer.json"
        ),
        "roberta-large-openai-detector": (
            "https://huggingface.co/roberta-large-openai-detector/resolve/main/tokenizer.json"
        ),
    },
}

__UpperCamelCase					    =	{
    "roberta-base": 512,
    "roberta-large": 512,
    "roberta-large-mnli": 512,
    "distilroberta-base": 512,
    "roberta-base-openai-detector": 512,
    "roberta-large-openai-detector": 512,
}




class  _A (					__lowercase		):
		lowercase__:   List[str]				     =   VOCAB_FILES_NAMES
		lowercase__:   str				     =   PRETRAINED_VOCAB_FILES_MAP
		lowercase__:   List[str]				     =   PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
		lowercase__:   List[str]				     =   ['''input_ids''', '''attention_mask''']
		lowercase__:   Optional[int]				     =   RobertaTokenizer

		def __init__(   self					:   List[str]  ,      __magic_name__					:   Any=None  ,      __magic_name__					:   Dict=None  ,      __magic_name__					:   List[str]=None  ,      __magic_name__					:   Any="replace"  ,      __magic_name__					:   int="<s>"  ,      __magic_name__					:   Union[str, Any]="</s>"  ,      __magic_name__					:   Any="</s>"  ,      __magic_name__					:   List[Any]="<s>"  ,      __magic_name__					:   Optional[int]="<unk>"  ,      __magic_name__					:   Any="<pad>"  ,      __magic_name__					:   str="<mask>"  ,      __magic_name__					:   int=False  ,      __magic_name__					:   Optional[Any]=True  ,      **__magic_name__					:   str  ,      )					->    Optional[Any]:


					"""simple docstring"""

					super().__init__(
					    __magic_name__  ,      __magic_name__  ,      tokenizer_file=__magic_name__  ,      errors=__magic_name__  ,      bos_token=__magic_name__  ,      eos_token=__magic_name__  ,      sep_token=__magic_name__  ,      cls_token=__magic_name__  ,      unk_token=__magic_name__  ,      pad_token=__magic_name__  ,      mask_token=__magic_name__  ,      add_prefix_space=__magic_name__  ,      trim_offsets=__magic_name__  ,      **__magic_name__  ,      )

					__snake_case					:      List[str]							      =     json.loads(self.backend_tokenizer.pre_tokenizer.__getstate__()			)
					if pre_tok_state.get("""add_prefix_space"""  ,      __magic_name__			) != add_prefix_space:
								__snake_case					:      Union[str, Any]							      =     getattr(__magic_name__  ,      pre_tok_state.pop("""type"""			)			)
								__snake_case					:      Optional[Any]							      =     add_prefix_space
								__snake_case					:      List[str]							      =     pre_tok_class(**__magic_name__			)

					__snake_case					:      int							      =     add_prefix_space

					__snake_case					:      Dict							      =     """post_processor"""
					__snake_case					:      List[Any]							      =     getattr(self.backend_tokenizer  ,      __magic_name__  ,      __magic_name__			)
					if tokenizer_component_instance:
								__snake_case					:      str							      =     json.loads(tokenizer_component_instance.__getstate__()			)

								# The lists 'sep' and 'cls' must be cased in tuples for the object `post_processor_class`
								if "sep" in state:
											__snake_case					:      Optional[Any]							      =     tuple(state["""sep"""]			)
								if "cls" in state:
											__snake_case					:      str							      =     tuple(state["""cls"""]			)

								__snake_case					:      Optional[int]							      =     False

								if state.get("""add_prefix_space"""  ,      __magic_name__			) != add_prefix_space:
											__snake_case					:      Union[str, Any]							      =     add_prefix_space
											__snake_case					:      List[str]							      =     True

								if state.get("""trim_offsets"""  ,      __magic_name__			) != trim_offsets:
											__snake_case					:      List[str]							      =     trim_offsets
											__snake_case					:      Any							      =     True

								if changes_to_apply:
											__snake_case					:      Tuple							      =     getattr(__magic_name__  ,      state.pop("""type"""			)			)
											__snake_case					:      str							      =     component_class(**__magic_name__			)
											setattr(self.backend_tokenizer  ,      __magic_name__  ,      __magic_name__			)

		@property
		def 	lowercase__     (   self					:   Union[str, Any]			)					->    str:


					"""simple docstring"""

					if self._mask_token is None:
								if self.verbose:
											logger.error("""Using mask_token, but it is not set yet."""			)
								return None
					return str(self._mask_token			)

		@mask_token.setter
		def 	lowercase__     (   self					:   Optional[Any]  ,      __magic_name__					:   List[str]			)					->    Dict:


					"""simple docstring"""

					__snake_case					:      List[Any]							      =     AddedToken(__magic_name__  ,      lstrip=__magic_name__  ,      rstrip=__magic_name__			) if isinstance(__magic_name__  ,      __magic_name__			) else value
					__snake_case					:      List[Any]							      =     value

		def 	lowercase__     (   self					:   Union[str, Any]  ,      *__magic_name__					:   Tuple  ,      **__magic_name__					:   List[Any]			)					->    BatchEncoding:


					"""simple docstring"""

					__snake_case					:      Any							      =     kwargs.get("""is_split_into_words"""  ,      __magic_name__			)
					assert self.add_prefix_space or not is_split_into_words, (
					    f'''You need to instantiate {self.__class__.__name__} with add_prefix_space=True '''
					    "to use it with pretokenized inputs."
					)

					return super()._batch_encode_plus(*__magic_name__  ,      **__magic_name__			)

		def 	lowercase__     (   self					:   List[Any]  ,      *__magic_name__					:   Any  ,      **__magic_name__					:   Optional[Any]			)					->    BatchEncoding:


					"""simple docstring"""

					__snake_case					:      List[str]							      =     kwargs.get("""is_split_into_words"""  ,      __magic_name__			)

					assert self.add_prefix_space or not is_split_into_words, (
					    f'''You need to instantiate {self.__class__.__name__} with add_prefix_space=True '''
					    "to use it with pretokenized inputs."
					)

					return super()._encode_plus(*__magic_name__  ,      **__magic_name__			)

		def 	lowercase__     (   self					:   Dict  ,      __magic_name__					:   str  ,      __magic_name__					:   Optional[str] = None			)					->    Tuple[str]:


					"""simple docstring"""

					__snake_case					:      int							      =     self._tokenizer.model.save(__magic_name__  ,      name=__magic_name__			)
					return tuple(__magic_name__			)

		def 	lowercase__     (   self					:   Optional[Any]  ,      __magic_name__					:   Optional[int]  ,      __magic_name__					:   Dict=None			)					->    Dict:


					"""simple docstring"""

					__snake_case					:      Optional[Any]							      =     [self.bos_token_id] + token_ids_a + [self.eos_token_id]
					if token_ids_a is None:
								return output

					return output + [self.eos_token_id] + token_ids_a + [self.eos_token_id]

		def 	lowercase__     (   self					:   List[str]  ,      __magic_name__					:   List[int]  ,      __magic_name__					:   Optional[List[int]] = None			)					->    List[int]:


					"""simple docstring"""

					__snake_case					:      List[str]							      =     [self.sep_token_id]
					__snake_case					:      Optional[Any]							      =     [self.cls_token_id]

					if token_ids_a is None:
								return len(cls + token_ids_a + sep			) * [0]
					return len(cls + token_ids_a + sep + sep + token_ids_a + sep			) * [0]








"""simple docstring"""




def        a__					(							)		->   int:
			return 1



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



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



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



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



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



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



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



def        a__					(							snake_case__ = 2_00							)		->   int:
			return two_pound(snake_case__							)


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



