






import os
import unittest

from transformers import BatchEncoding
from transformers.models.bert.tokenization_bert import (
    BasicTokenizer,
    WordpieceTokenizer,
    _is_control,
    _is_punctuation,
    _is_whitespace,
)
from transformers.models.prophetnet.tokenization_prophetnet import VOCAB_FILES_NAMES, ProphetNetTokenizer
from transformers.testing_utils import require_torch, slow

from ...test_tokenization_common import TokenizerTesterMixin




class 			snake_case__   (							lowercase_	,    unittest.TestCase):

       '''simple docstring'''
       lowerCamelCase							:				str 				= ProphetNetTokenizer
       lowerCamelCase							:				Optional[Any] 				= False



       def 					__lowercase						(							self    ) ->      List[Any]:






            '''simple docstring'''





            super().setUp()

            __snake_case			:List[Any]          =						[
                """[UNK]""",
                """[CLS]""",
                """[SEP]""",
                """[PAD]""",
                """[MASK]""",
                """want""",
                """##want""",
                """##ed""",
                """wa""",
                """un""",
                """runn""",
                """##ing""",
                """,""",
                """low""",
                """lowest""",
            ]
            __snake_case			:int          =						os.path.join(self.tmpdirname			,						VOCAB_FILES_NAMES["""vocab_file"""]    )
            with open(self.vocab_file			,						"""w"""			,						encoding="""utf-8"""    ) as vocab_writer:
                 vocab_writer.write("""""".join([x + """\n""" for x in vocab_tokens]    )    )



       def 					__lowercase						(							self			,						a__    ) ->      Dict:






            '''simple docstring'''





            __snake_case			:Union[str, Any]          =						"""UNwant\u00E9d,running"""
            __snake_case			:Union[str, Any]          =						"""unwanted, running"""
            return input_text, output_text



       def 					__lowercase						(							self    ) ->      int:






            '''simple docstring'''





            __snake_case			:Optional[Any]          =						self.tokenizer_class(self.vocab_file    )

            __snake_case			:List[str]          =						tokenizer.tokenize("""UNwant\u00E9d,running"""    )
            self.assertListEqual(a__			,						["""un""", """##want""", """##ed""", """,""", """runn""", """##ing"""]    )
            self.assertListEqual(tokenizer.convert_tokens_to_ids(a__    )			,						[9, 6, 7, 12, 10, 11]    )



       def 					__lowercase						(							self    ) ->      int:






            '''simple docstring'''





            __snake_case			:Optional[Any]          =						BasicTokenizer()

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



       def 					__lowercase						(							self    ) ->      str:






            '''simple docstring'''





            __snake_case			:str          =						BasicTokenizer(do_lower_case=a__    )

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



       def 					__lowercase						(							self    ) ->      List[Any]:






            '''simple docstring'''





            __snake_case			:List[Any]          =						BasicTokenizer(do_lower_case=a__			,						strip_accents=a__    )

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



       def 					__lowercase						(							self    ) ->      Optional[Any]:






            '''simple docstring'''





            __snake_case			:List[Any]          =						BasicTokenizer(do_lower_case=a__			,						strip_accents=a__    )

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



       def 					__lowercase						(							self    ) ->      Any:






            '''simple docstring'''





            __snake_case			:Dict          =						BasicTokenizer(do_lower_case=a__    )

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



       def 					__lowercase						(							self    ) ->      Optional[int]:






            '''simple docstring'''





            __snake_case			:int          =						BasicTokenizer(do_lower_case=a__    )

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



       def 					__lowercase						(							self    ) ->      Dict:






            '''simple docstring'''





            __snake_case			:Tuple          =						BasicTokenizer(do_lower_case=a__			,						strip_accents=a__    )

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



       def 					__lowercase						(							self    ) ->      Optional[int]:






            '''simple docstring'''





            __snake_case			:Optional[Any]          =						BasicTokenizer(do_lower_case=a__			,						strip_accents=a__    )

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



       def 					__lowercase						(							self    ) ->      Optional[Any]:






            '''simple docstring'''





            __snake_case			:Optional[int]          =						BasicTokenizer(do_lower_case=a__			,						never_split=["""[UNK]"""]    )

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



       def 					__lowercase						(							self    ) ->      Any:






            '''simple docstring'''





            __snake_case			:List[str]          =						["""[UNK]""", """[CLS]""", """[SEP]""", """want""", """##want""", """##ed""", """wa""", """un""", """runn""", """##ing"""]

            __snake_case			:Optional[Any]          =						{}
            for i, token in enumerate(a__    ):
                 __snake_case			:str          =						i
            __snake_case			:int          =						WordpieceTokenizer(vocab=a__			,						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"""]    )



       @require_torch
       def 					__lowercase						(							self    ) ->      Optional[int]:






            '''simple docstring'''





            __snake_case			:Any          =						self.tokenizer_class.from_pretrained("""microsoft/prophetnet-large-uncased"""    )

            __snake_case			:Union[str, Any]          =						["""A long paragraph for summarization.""", """Another paragraph for summarization."""]
            __snake_case			:List[Any]          =						[10_37, 21_46, 2_04_23, 20_05, 76_80, 78_49, 39_89, 10_12, 1_02]
            __snake_case			:Optional[Any]          =						tokenizer(a__			,						padding=a__			,						return_tensors="""pt"""    )
            self.assertIsInstance(a__			,						a__    )
            __snake_case			:List[Any]          =						list(batch.input_ids.numpy()[0]    )
            self.assertListEqual(a__			,						a__    )

            self.assertEqual((2, 9)			,						batch.input_ids.shape    )
            self.assertEqual((2, 9)			,						batch.attention_mask.shape    )



       def 					__lowercase						(							self    ) ->      Dict:






            '''simple docstring'''





            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 					__lowercase						(							self    ) ->      Dict:






            '''simple docstring'''





            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 					__lowercase						(							self    ) ->      Optional[Any]:






            '''simple docstring'''





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



       @slow
       def 					__lowercase						(							self    ) ->      Optional[int]:






            '''simple docstring'''





            __snake_case			:List[Any]          =						self.tokenizer_class.from_pretrained("""microsoft/prophetnet-large-uncased"""    )

            __snake_case			:Optional[Any]          =						tokenizer.encode("""sequence builders"""			,						add_special_tokens=a__    )
            __snake_case			:Optional[Any]          =						tokenizer.encode("""multi-sequence build"""			,						add_special_tokens=a__    )

            __snake_case			:Optional[int]          =						tokenizer.build_inputs_with_special_tokens(a__    )
            __snake_case			:str          =						tokenizer.build_inputs_with_special_tokens(a__			,						a__    )

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










import math

lowerCamelCase__							=     10
lowerCamelCase__							=     7
lowerCamelCase__							=     BALLS_PER_COLOUR * NUM_COLOURS






def   UpperCamelCase  (       snake_case__     :   int = 20  ):




     '''simple docstring'''






     __snake_case			:Dict          =						math.comb(snake_case__	,snake_case__  )
     __snake_case			:int          =						math.comb(NUM_BALLS - BALLS_PER_COLOUR	,snake_case__  )

     __snake_case			:List[str]          =						NUM_COLOURS * (1 - missing_colour / total)

     return f'''{result:.9f}'''


if __name__ == "__main__":
     print(solution(20))


