

"""simple docstring"""




import json
import os
import unittest

from transformers.models.roc_bert.tokenization_roc_bert import (
    VOCAB_FILES_NAMES,
    RoCBertBasicTokenizer,
    RoCBertTokenizer,
    RoCBertWordpieceTokenizer,
    _is_control,
    _is_punctuation,
    _is_whitespace,
)
from transformers.testing_utils import require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin, filter_non_english


@require_tokenizers
class 		_A       (			__a				,       unittest.TestCase					):
      __a								=	RoCBertTokenizer
      __a								=	None
      __a								=	False
      __a								=	True
      __a								=	filter_non_english





      def 					_lowerCamelCase  (  self		)   ->					str:
         super().setUp()

         lowerCamelCase__						=			["[UNK]", "[CLS]", "[SEP]", "[PAD]", "[MASK]", "你", "好", "是", "谁", "a", "b", "c", "d"]
         lowerCamelCase__						=			{}
         lowerCamelCase__						=			{}
         for i, value in enumerate(SCREAMING_SNAKE_CASE__		):
            lowerCamelCase__						=			i
            lowerCamelCase__						=			i
         lowerCamelCase__						=			os.path.join(self.tmpdirname    ,						VOCAB_FILES_NAMES["vocab_file"]		)
         lowerCamelCase__						=			os.path.join(self.tmpdirname    ,						VOCAB_FILES_NAMES["word_shape_file"]		)
         lowerCamelCase__						=			os.path.join(self.tmpdirname    ,						VOCAB_FILES_NAMES["word_pronunciation_file"]		)
         with open(self.vocab_file    ,						"w"    ,						encoding="utf-8"		) as vocab_writer:
            vocab_writer.write("".join([x + "\n" for x in vocab_tokens]		)		)
         with open(self.word_shape_file    ,						"w"    ,						encoding="utf-8"		) as word_shape_writer:
            json.dump(SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						ensure_ascii=SCREAMING_SNAKE_CASE__		)
         with open(self.word_pronunciation_file    ,						"w"    ,						encoding="utf-8"		) as word_pronunciation_writer:
            json.dump(SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						ensure_ascii=SCREAMING_SNAKE_CASE__		)





      def 					_lowerCamelCase  (  self		)   ->					List[str]:
         lowerCamelCase__						=			self.tokenizer_class(self.vocab_file    ,						self.word_shape_file    ,						self.word_pronunciation_file		)

         lowerCamelCase__						=			tokenizer.tokenize("你好[SEP]你是谁"		)
         self.assertListEqual(SCREAMING_SNAKE_CASE__    ,						["你", "好", "[SEP]", "你", "是", "谁"]		)
         self.assertListEqual(tokenizer.convert_tokens_to_ids(SCREAMING_SNAKE_CASE__		)    ,						[5, 6, 2, 5, 7, 8]		)
         self.assertListEqual(tokenizer.convert_tokens_to_shape_ids(SCREAMING_SNAKE_CASE__		)    ,						[5, 6, 2, 5, 7, 8]		)
         self.assertListEqual(tokenizer.convert_tokens_to_pronunciation_ids(SCREAMING_SNAKE_CASE__		)    ,						[5, 6, 2, 5, 7, 8]		)





      def 					_lowerCamelCase  (  self		)   ->					List[Any]:
         lowerCamelCase__						=			RoCBertBasicTokenizer()

         self.assertListEqual(tokenizer.tokenize("ah\u535A\u63A8zz"		)    ,						["ah", "\u535A", "\u63A8", "zz"]		)





      def 					_lowerCamelCase  (  self		)   ->					Optional[int]:
         lowerCamelCase__						=			RoCBertBasicTokenizer(do_lower_case=SCREAMING_SNAKE_CASE__		)

         self.assertListEqual(
             tokenizer.tokenize(" \tHeLLo!how  \n Are yoU?  "		)    ,						["hello", "!", "how", "are", "you", "?"]		)
         self.assertListEqual(tokenizer.tokenize("H\u00E9llo"		)    ,						["hello"]		)





      def 					_lowerCamelCase  (  self		)   ->					List[str]:
         lowerCamelCase__						=			RoCBertBasicTokenizer(do_lower_case=SCREAMING_SNAKE_CASE__    ,						strip_accents=SCREAMING_SNAKE_CASE__		)

         self.assertListEqual(
             tokenizer.tokenize(" \tHäLLo!how  \n Are yoU?  "		)    ,						["hällo", "!", "how", "are", "you", "?"]		)
         self.assertListEqual(tokenizer.tokenize("H\u00E9llo"		)    ,						["h\u00E9llo"]		)





      def 					_lowerCamelCase  (  self		)   ->					Tuple:
         lowerCamelCase__						=			RoCBertBasicTokenizer(do_lower_case=SCREAMING_SNAKE_CASE__    ,						strip_accents=SCREAMING_SNAKE_CASE__		)

         self.assertListEqual(
             tokenizer.tokenize(" \tHäLLo!how  \n Are yoU?  "		)    ,						["hallo", "!", "how", "are", "you", "?"]		)
         self.assertListEqual(tokenizer.tokenize("H\u00E9llo"		)    ,						["hello"]		)





      def 					_lowerCamelCase  (  self		)   ->					Optional[int]:
         lowerCamelCase__						=			RoCBertBasicTokenizer(do_lower_case=SCREAMING_SNAKE_CASE__		)

         self.assertListEqual(
             tokenizer.tokenize(" \tHäLLo!how  \n Are yoU?  "		)    ,						["hallo", "!", "how", "are", "you", "?"]		)
         self.assertListEqual(tokenizer.tokenize("H\u00E9llo"		)    ,						["hello"]		)





      def 					_lowerCamelCase  (  self		)   ->					str:
         lowerCamelCase__						=			RoCBertBasicTokenizer(do_lower_case=SCREAMING_SNAKE_CASE__		)

         self.assertListEqual(
             tokenizer.tokenize(" \tHeLLo!how  \n Are yoU?  "		)    ,						["HeLLo", "!", "how", "Are", "yoU", "?"]		)





      def 					_lowerCamelCase  (  self		)   ->					Optional[int]:
         lowerCamelCase__						=			RoCBertBasicTokenizer(do_lower_case=SCREAMING_SNAKE_CASE__    ,						strip_accents=SCREAMING_SNAKE_CASE__		)

         self.assertListEqual(
             tokenizer.tokenize(" \tHäLLo!how  \n Are yoU?  "		)    ,						["HäLLo", "!", "how", "Are", "yoU", "?"]		)





      def 					_lowerCamelCase  (  self		)   ->					Union[str, Any]:
         lowerCamelCase__						=			RoCBertBasicTokenizer(do_lower_case=SCREAMING_SNAKE_CASE__    ,						strip_accents=SCREAMING_SNAKE_CASE__		)

         self.assertListEqual(
             tokenizer.tokenize(" \tHäLLo!how  \n Are yoU?  "		)    ,						["HaLLo", "!", "how", "Are", "yoU", "?"]		)





      def 					_lowerCamelCase  (  self		)   ->					Tuple:
         lowerCamelCase__						=			RoCBertBasicTokenizer(do_lower_case=SCREAMING_SNAKE_CASE__    ,						never_split=["[UNK]"]		)

         self.assertListEqual(
             tokenizer.tokenize(" \tHeLLo!how  \n Are yoU? [UNK]"		)    ,						["HeLLo", "!", "how", "Are", "yoU", "?", "[UNK]"]		)





      def 					_lowerCamelCase  (  self		)   ->					Tuple:
         lowerCamelCase__						=			["[UNK]", "[CLS]", "[SEP]", "want", "##want", "##ed", "wa", "un", "runn", "##ing"]

         lowerCamelCase__						=			{}
         for i, token in enumerate(SCREAMING_SNAKE_CASE__		):
            lowerCamelCase__						=			i
         lowerCamelCase__						=			RoCBertWordpieceTokenizer(vocab=SCREAMING_SNAKE_CASE__    ,						unk_token="[UNK]"		)

         self.assertListEqual(tokenizer.tokenize(""		)    ,						[]		)

         self.assertListEqual(tokenizer.tokenize("unwanted running"		)    ,						["un", "##want", "##ed", "runn", "##ing"]		)

         self.assertListEqual(tokenizer.tokenize("unwantedX running"		)    ,						["[UNK]", "runn", "##ing"]		)





      def 					_lowerCamelCase  (  self		)   ->					Optional[Any]:
         self.assertTrue(_is_whitespace(" "		)		)
         self.assertTrue(_is_whitespace("\t"		)		)
         self.assertTrue(_is_whitespace("\r"		)		)
         self.assertTrue(_is_whitespace("\n"		)		)
         self.assertTrue(_is_whitespace("\u00A0"		)		)

         self.assertFalse(_is_whitespace("A"		)		)
         self.assertFalse(_is_whitespace("-"		)		)





      def 					_lowerCamelCase  (  self		)   ->					Union[str, Any]:
         self.assertTrue(_is_control("\u0005"		)		)

         self.assertFalse(_is_control("A"		)		)
         self.assertFalse(_is_control(" "		)		)
         self.assertFalse(_is_control("\t"		)		)
         self.assertFalse(_is_control("\r"		)		)





      def 					_lowerCamelCase  (  self		)   ->					Optional[Any]:
         self.assertTrue(_is_punctuation("-"		)		)
         self.assertTrue(_is_punctuation("$"		)		)
         self.assertTrue(_is_punctuation("`"		)		)
         self.assertTrue(_is_punctuation("."		)		)

         self.assertFalse(_is_punctuation("A"		)		)
         self.assertFalse(_is_punctuation(" "		)		)





      def 					_lowerCamelCase  (  self		)   ->					Any:
         lowerCamelCase__						=			self.get_tokenizer()

         # Example taken from the issue https://github.com/huggingface/tokenizers/issues/340
         self.assertListEqual([tokenizer.tokenize(SCREAMING_SNAKE_CASE__		) for t in ["Test", "\xad", "test"]]    ,						[["[UNK]"], [], ["[UNK]"]]		)

         if self.test_rust_tokenizer:
            lowerCamelCase__						=			self.get_rust_tokenizer()
            self.assertListEqual(
                [rust_tokenizer.tokenize(SCREAMING_SNAKE_CASE__		) for t in ["Test", "\xad", "test"]]    ,						[["[UNK]"], [], ["[UNK]"]]		)





      def 					_lowerCamelCase  (  self		)   ->					List[Any]:
         for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
            with self.subTest(f'{tokenizer.__class__.__name__} ({pretrained_name})'		):
               lowerCamelCase__						=			self.rust_tokenizer_class.from_pretrained(SCREAMING_SNAKE_CASE__    ,						**SCREAMING_SNAKE_CASE__		)

               lowerCamelCase__						=			f'A, naïve {tokenizer_r.mask_token} AllenNLP sentence.'
               lowerCamelCase__						=			tokenizer_r.encode_plus(
                   SCREAMING_SNAKE_CASE__    ,						return_attention_mask=SCREAMING_SNAKE_CASE__    ,						return_token_type_ids=SCREAMING_SNAKE_CASE__    ,						return_offsets_mapping=SCREAMING_SNAKE_CASE__    ,						add_special_tokens=SCREAMING_SNAKE_CASE__    ,						)

               lowerCamelCase__						=			tokenizer_r.do_lower_case if hasattr(SCREAMING_SNAKE_CASE__    ,						"do_lower_case"		) else False
               lowerCamelCase__						=			(
                   [
                       ((0, 0), tokenizer_r.cls_token),
                       ((0, 1), "A"),
                       ((1, 2), ","),
                       ((3, 5), "na"),
                       ((5, 6), "##ï"),
                       ((6, 8), "##ve"),
                       ((9, 15), tokenizer_r.mask_token),
                       ((16, 21), "Allen"),
                       ((21, 23), "##NL"),
                       ((23, 24), "##P"),
                       ((25, 33), "sentence"),
                       ((33, 34), "."),
                       ((0, 0), tokenizer_r.sep_token),
                   ]
                   if not do_lower_case
                   else [
                       ((0, 0), tokenizer_r.cls_token),
                       ((0, 1), "a"),
                       ((1, 2), ","),
                       ((3, 8), "naive"),
                       ((9, 15), tokenizer_r.mask_token),
                       ((16, 21), "allen"),
                       ((21, 23), "##nl"),
                       ((23, 24), "##p"),
                       ((25, 33), "sentence"),
                       ((33, 34), "."),
                       ((0, 0), tokenizer_r.sep_token),
                   ]
               )

               self.assertEqual(
                   [e[1] for e in expected_results]    ,						tokenizer_r.convert_ids_to_tokens(tokens["input_ids"]		)		)
               self.assertEqual([e[0] for e in expected_results]    ,						tokens["offset_mapping"]		)





      def 					_lowerCamelCase  (  self		)   ->					Optional[Any]:
         lowerCamelCase__						=			["的", "人", "有"]
         lowerCamelCase__						=			"".join(SCREAMING_SNAKE_CASE__		)
         for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
            with self.subTest(f'{tokenizer.__class__.__name__} ({pretrained_name})'		):
               lowerCamelCase__						=			True
               lowerCamelCase__						=			self.tokenizer_class.from_pretrained(SCREAMING_SNAKE_CASE__    ,						**SCREAMING_SNAKE_CASE__		)
               lowerCamelCase__						=			self.rust_tokenizer_class.from_pretrained(SCREAMING_SNAKE_CASE__    ,						**SCREAMING_SNAKE_CASE__		)

               lowerCamelCase__						=			tokenizer_p.encode(SCREAMING_SNAKE_CASE__    ,						add_special_tokens=SCREAMING_SNAKE_CASE__		)
               lowerCamelCase__						=			tokenizer_r.encode(SCREAMING_SNAKE_CASE__    ,						add_special_tokens=SCREAMING_SNAKE_CASE__		)

               lowerCamelCase__						=			tokenizer_r.convert_ids_to_tokens(SCREAMING_SNAKE_CASE__		)
               lowerCamelCase__						=			tokenizer_p.convert_ids_to_tokens(SCREAMING_SNAKE_CASE__		)

               # it is expected that each Chinese character is not preceded by "##"
               self.assertListEqual(SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__		)
               self.assertListEqual(SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__		)

               lowerCamelCase__						=			False
               lowerCamelCase__						=			self.rust_tokenizer_class.from_pretrained(SCREAMING_SNAKE_CASE__    ,						**SCREAMING_SNAKE_CASE__		)
               lowerCamelCase__						=			self.tokenizer_class.from_pretrained(SCREAMING_SNAKE_CASE__    ,						**SCREAMING_SNAKE_CASE__		)

               lowerCamelCase__						=			tokenizer_r.encode(SCREAMING_SNAKE_CASE__    ,						add_special_tokens=SCREAMING_SNAKE_CASE__		)
               lowerCamelCase__						=			tokenizer_p.encode(SCREAMING_SNAKE_CASE__    ,						add_special_tokens=SCREAMING_SNAKE_CASE__		)

               lowerCamelCase__						=			tokenizer_r.convert_ids_to_tokens(SCREAMING_SNAKE_CASE__		)
               lowerCamelCase__						=			tokenizer_p.convert_ids_to_tokens(SCREAMING_SNAKE_CASE__		)

               # it is expected that only the first Chinese character is not preceded by "##".
               lowerCamelCase__						=			[
                   f'##{token}' if idx != 0 else token for idx, token in enumerate(SCREAMING_SNAKE_CASE__		)
               ]
               self.assertListEqual(SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__		)
               self.assertListEqual(SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__		)





      @slow
      def 					_lowerCamelCase  (  self		)   ->					int:
         lowerCamelCase__						=			self.tokenizer_class(self.vocab_file    ,						self.word_shape_file    ,						self.word_pronunciation_file		)

         lowerCamelCase__						=			tokenizer.encode("你好"    ,						add_special_tokens=SCREAMING_SNAKE_CASE__		)
         lowerCamelCase__						=			tokenizer.encode("你是谁"    ,						add_special_tokens=SCREAMING_SNAKE_CASE__		)

         lowerCamelCase__						=			tokenizer.build_inputs_with_special_tokens(SCREAMING_SNAKE_CASE__		)
         lowerCamelCase__						=			tokenizer.build_inputs_with_special_tokens(SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__		)

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





      def 					_lowerCamelCase  (  self		)   ->					Optional[int]:
         lowerCamelCase__						=			self.get_tokenizers(do_lower_case=SCREAMING_SNAKE_CASE__		)
         for tokenizer in tokenizers:
            with self.subTest(f'{tokenizer.__class__.__name__}'		):
               lowerCamelCase__						=			"你好，你是谁"
               lowerCamelCase__						=			tokenizer.tokenize(SCREAMING_SNAKE_CASE__		)
               lowerCamelCase__						=			tokenizer.convert_tokens_to_ids(SCREAMING_SNAKE_CASE__		)
               lowerCamelCase__						=			tokenizer.convert_tokens_to_shape_ids(SCREAMING_SNAKE_CASE__		)
               lowerCamelCase__						=			tokenizer.convert_tokens_to_pronunciation_ids(SCREAMING_SNAKE_CASE__		)
               lowerCamelCase__						=			tokenizer.prepare_for_model(
                   SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						add_special_tokens=SCREAMING_SNAKE_CASE__		)

               lowerCamelCase__						=			tokenizer.encode_plus(SCREAMING_SNAKE_CASE__    ,						add_special_tokens=SCREAMING_SNAKE_CASE__		)

               self.assertEqual(SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__		)







"""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())))




