




"""simple docstring"""

import json
import os
import unittest

from transformers.models.xlm.tokenization_xlm import VOCAB_FILES_NAMES, XLMTokenizer
from transformers.testing_utils import slow

from ...test_tokenization_common import TokenizerTesterMixin
class 	lowerCamelCase__			(     __SCREAMING_SNAKE_CASE ,     unittest.TestCase	):
			a__       :					str	    =   XLMTokenizer
			a__       :					Optional[Any]	    =   False


			def 							lowerCamelCase_ (   self							):



					"""simple docstring"""







					super().setUp()

					# Adapted from Sennrich et al. 2015 and https://github.com/rsennrich/subword-nmt
					snake_case						:  Optional[Any]    	= [
					    "l",
					    "o",
					    "w",
					    "e",
					    "r",
					    "s",
					    "t",
					    "i",
					    "d",
					    "n",
					    "w</w>",
					    "r</w>",
					    "t</w>",
					    "lo",
					    "low",
					    "er</w>",
					    "low</w>",
					    "lowest</w>",
					    "newer</w>",
					    "wider</w>",
					    "<unk>",
					]
					snake_case						:  Any    	= dict(zip(_SCREAMING_SNAKE_CASE ,       range(len(_SCREAMING_SNAKE_CASE							)							)							)							)
					snake_case						:  int    	= ["l o 123", "lo w 1456", "e r</w> 1789", ""]

					snake_case						:  Any    	= os.path.join(self.tmpdirname ,       VOCAB_FILES_NAMES["vocab_file"]							)
					snake_case						:  Union[str, Any]    	= os.path.join(self.tmpdirname ,       VOCAB_FILES_NAMES["merges_file"]							)
					with open(self.vocab_file ,       "w"							) as fp:
							fp.write(json.dumps(_SCREAMING_SNAKE_CASE							)							)
					with open(self.merges_file ,       "w"							) as fp:
							fp.write("\n".join(_SCREAMING_SNAKE_CASE							)							)


			def 							lowerCamelCase_ (   self ,       SCREAMING_SNAKE_CASE							):



					"""simple docstring"""







					snake_case						:  str    	= "lower newer"
					snake_case						:  List[Any]    	= "lower newer"
					return input_text, output_text


			def 							lowerCamelCase_ (   self							):



					"""simple docstring"""







					snake_case						:  Any    	= XLMTokenizer(self.vocab_file ,       self.merges_file							)

					snake_case						:  Dict    	= "lower"
					snake_case						:  List[Any]    	= ["low", "er</w>"]
					snake_case						:  Union[str, Any]    	= tokenizer.tokenize(_SCREAMING_SNAKE_CASE							)
					self.assertListEqual(_SCREAMING_SNAKE_CASE ,       _SCREAMING_SNAKE_CASE							)

					snake_case						:  int    	= tokens + ["<unk>"]
					snake_case						:  Tuple    	= [14, 15, 20]
					self.assertListEqual(tokenizer.convert_tokens_to_ids(_SCREAMING_SNAKE_CASE							) ,       _SCREAMING_SNAKE_CASE							)



			@slow
			def 							lowerCamelCase_ (   self							):



					"""simple docstring"""







					snake_case						:  List[str]    	= XLMTokenizer.from_pretrained("xlm-mlm-en-2048"							)

					snake_case						:  int    	= tokenizer.encode("sequence builders" ,       add_special_tokens=_SCREAMING_SNAKE_CASE							)
					snake_case						:  List[str]    	= tokenizer.encode("multi-sequence build" ,       add_special_tokens=_SCREAMING_SNAKE_CASE							)

					snake_case						:  Optional[Any]    	= tokenizer.build_inputs_with_special_tokens(_SCREAMING_SNAKE_CASE							)
					snake_case						:  List[Any]    	= tokenizer.build_inputs_with_special_tokens(_SCREAMING_SNAKE_CASE ,       _SCREAMING_SNAKE_CASE							)

					assert encoded_sentence == [0] + text + [1]
					assert encoded_pair == [0] + text + [1] + text_a + [1]






"""simple docstring"""






def 			_lowercase				(  )						->   int:
			return 1


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


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


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


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


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


def 			_lowercase				(  __snake_case	)						->   int:
			return 0 if x < 0 else one_pound(x - 100	) + fifty_pence(__snake_case	)


def 			_lowercase				(  __snake_case	)						->   int:
			return 0 if x < 0 else two_pound(x - 200	) + one_pound(__snake_case	)


def 			_lowercase				(  __snake_case = 200	)						->   int:
			return two_pound(__snake_case	)


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