'''simple docstring'''

import unittest

from transformers import BigBirdTokenizer, BigBirdTokenizerFast
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, require_torch, slow
from transformers.utils import cached_property

from ...test_tokenization_common import TokenizerTesterMixin


__a: Tuple          =   """▁"""

__a: Optional[int]          =   get_tests_dir("""fixtures/test_sentencepiece.model""")



@require_sentencepiece
@require_tokenizers
class 			UpperCAmelCase  (						a__    ,						unittest.TestCase					):





       '''simple docstring'''



       SCREAMING_SNAKE_CASE							=    BigBirdTokenizer
       SCREAMING_SNAKE_CASE							=    BigBirdTokenizerFast
       SCREAMING_SNAKE_CASE							=    True
       SCREAMING_SNAKE_CASE							=    True

       def _lowerCAmelCase(						self )  ->  List[Any]:
        super().setUp()

        lowercase__				:    Optional[int]  =					self.tokenizer_class(__lowerCAmelCase	,   keep_accents=__lowerCAmelCase )
        tokenizer.save_pretrained(self.tmpdirname )

       def _lowerCAmelCase(						self )  ->  Union[str, Any]:
        lowercase__				:    Union[str, Any]  =					'''<s>'''
        lowercase__				:    List[Any]  =					1

        self.assertEqual(self.get_tokenizer()._convert_token_to_id(__lowerCAmelCase )	,   __lowerCAmelCase )
        self.assertEqual(self.get_tokenizer()._convert_id_to_token(__lowerCAmelCase )	,   __lowerCAmelCase )

       def _lowerCAmelCase(						self )  ->  Dict:
        lowercase__				:    int  =					list(self.get_tokenizer().get_vocab().keys() )

        self.assertEqual(vocab_keys[0]	,   '''<unk>''' )
        self.assertEqual(vocab_keys[1]	,   '''<s>''' )
        self.assertEqual(vocab_keys[-1]	,   '''[MASK]''' )
        self.assertEqual(len(__lowerCAmelCase )	,   1004 )

       def _lowerCAmelCase(						self )  ->  List[Any]:
        self.assertEqual(self.get_tokenizer().vocab_size	,   1000 )

       def _lowerCAmelCase(						self )  ->  int:
        if not self.test_rust_tokenizer:
         return

        lowercase__				:    Union[str, Any]  =					self.get_tokenizer()
        lowercase__				:    Tuple  =					self.get_rust_tokenizer()

        lowercase__				:    int  =					'''I was born in 92000, and this is falsé.'''

        lowercase__				:    int  =					tokenizer.tokenize(__lowerCAmelCase )
        lowercase__				:    Dict  =					rust_tokenizer.tokenize(__lowerCAmelCase )
        self.assertListEqual(__lowerCAmelCase	,   __lowerCAmelCase )

        lowercase__				:    Optional[int]  =					tokenizer.encode(__lowerCAmelCase	,   add_special_tokens=__lowerCAmelCase )
        lowercase__				:    Union[str, Any]  =					rust_tokenizer.encode(__lowerCAmelCase	,   add_special_tokens=__lowerCAmelCase )
        self.assertListEqual(__lowerCAmelCase	,   __lowerCAmelCase )

        lowercase__				:    Any  =					self.get_rust_tokenizer()
        lowercase__				:    Tuple  =					tokenizer.encode(__lowerCAmelCase )
        lowercase__				:    Optional[int]  =					rust_tokenizer.encode(__lowerCAmelCase )
        self.assertListEqual(__lowerCAmelCase	,   __lowerCAmelCase )

       def _lowerCAmelCase(						self )  ->  int:
        lowercase__				:    Optional[int]  =					BigBirdTokenizer(__lowerCAmelCase	,   keep_accents=__lowerCAmelCase )

        lowercase__				:    int  =					tokenizer.tokenize('''This is a test''' )
        self.assertListEqual(__lowerCAmelCase	,   ['''▁This''', '''▁is''', '''▁a''', '''▁t''', '''est'''] )

        self.assertListEqual(
            tokenizer.convert_tokens_to_ids(__lowerCAmelCase )	,   [285, 46, 10, 170, 382]	,   )

        lowercase__				:    int  =					tokenizer.tokenize('''I was born in 92000, and this is falsé.''' )
        self.assertListEqual(
            __lowerCAmelCase	,   [
                SPIECE_UNDERLINE + '''I''',
                SPIECE_UNDERLINE + '''was''',
                SPIECE_UNDERLINE + '''b''',
                '''or''',
                '''n''',
                SPIECE_UNDERLINE + '''in''',
                SPIECE_UNDERLINE + '''''',
                '''9''',
                '''2''',
                '''0''',
                '''0''',
                '''0''',
                ''',''',
                SPIECE_UNDERLINE + '''and''',
                SPIECE_UNDERLINE + '''this''',
                SPIECE_UNDERLINE + '''is''',
                SPIECE_UNDERLINE + '''f''',
                '''al''',
                '''s''',
                '''é''',
                '''.''',
            ]	,   )
        lowercase__				:    Tuple  =					tokenizer.convert_tokens_to_ids(__lowerCAmelCase )
        self.assertListEqual(
            __lowerCAmelCase	,   [8, 21, 84, 55, 24, 19, 7, 0, 602, 347, 347, 347, 3, 12, 66, 46, 72, 80, 6, 0, 4]	,   )

        lowercase__				:    Any  =					tokenizer.convert_ids_to_tokens(__lowerCAmelCase )
        self.assertListEqual(
            __lowerCAmelCase	,   [
                SPIECE_UNDERLINE + '''I''',
                SPIECE_UNDERLINE + '''was''',
                SPIECE_UNDERLINE + '''b''',
                '''or''',
                '''n''',
                SPIECE_UNDERLINE + '''in''',
                SPIECE_UNDERLINE + '''''',
                '''<unk>''',
                '''2''',
                '''0''',
                '''0''',
                '''0''',
                ''',''',
                SPIECE_UNDERLINE + '''and''',
                SPIECE_UNDERLINE + '''this''',
                SPIECE_UNDERLINE + '''is''',
                SPIECE_UNDERLINE + '''f''',
                '''al''',
                '''s''',
                '''<unk>''',
                '''.''',
            ]	,   )

       @cached_property
       def _lowerCAmelCase(						self )  ->  Optional[Any]:
        return BigBirdTokenizer.from_pretrained('''google/bigbird-roberta-base''' )

       @slow
       def _lowerCAmelCase(						self )  ->  List[Any]:
        lowercase__				:    Tuple  =					'''Hello World!'''
        lowercase__				:    List[str]  =					[65, 18536, 2260, 101, 66]

        self.assertListEqual(__lowerCAmelCase	,   self.big_tokenizer.encode(__lowerCAmelCase ) )

       @slow
       def _lowerCAmelCase(						self )  ->  Optional[Any]:
        lowercase__				:    Union[str, Any]  =					(
            '''This is a very long text with a lot of weird characters, such as: . , ~ ? ( ) " [ ] ! : - . Also we will'''
            ''' add words that should not exsist and be tokenized to <unk>, such as saoneuhaoesuth'''
        )
        # fmt: off
        lowercase__				:    List[Any]  =					[65, 871, 419, 358, 946, 991, 2521, 452, 358, 1357, 387, 7751, 3536, 112, 985, 456, 126, 865, 938, 5400, 5734, 458, 1368, 467, 786, 2462, 5246, 1159, 633, 865, 4519, 457, 582, 852, 2557, 427, 916, 508, 405, 34324, 497, 391, 408, 11342, 1244, 385, 100, 938, 985, 456, 574, 362, 12597, 3200, 3129, 1172, 66]  # noqa: E231
        # fmt: on
        self.assertListEqual(__lowerCAmelCase	,   self.big_tokenizer.encode(__lowerCAmelCase ) )

       @require_torch
       @slow
       def _lowerCAmelCase(						self )  ->  str:
        import torch

        from transformers import BigBirdConfig, BigBirdModel

        # Build sequence
        lowercase__				:    Dict  =					list(self.big_tokenizer.get_vocab().keys() )[:10]
        lowercase__				:    Tuple  =					''' '''.join(__lowerCAmelCase )
        lowercase__				:    Union[str, Any]  =					self.big_tokenizer.encode_plus(__lowerCAmelCase	,   return_tensors='''pt'''	,   return_token_type_ids=__lowerCAmelCase )
        lowercase__				:    List[str]  =					self.big_tokenizer.batch_encode_plus(
            [sequence + ''' ''' + sequence]	,   return_tensors='''pt'''	,   return_token_type_ids=__lowerCAmelCase )

        lowercase__				:    Optional[int]  =					BigBirdConfig(attention_type='''original_full''' )
        lowercase__				:    int  =					BigBirdModel(__lowerCAmelCase )

        assert model.get_input_embeddings().weight.shape[0] >= self.big_tokenizer.vocab_size

        with torch.no_grad():
         model(**__lowerCAmelCase )
         model(**__lowerCAmelCase )

       @slow
       def _lowerCAmelCase(						self )  ->  Optional[int]:
        lowercase__				:    Optional[int]  =					BigBirdTokenizer.from_pretrained('''google/bigbird-roberta-base''' )
        lowercase__				:    Dict  =					tokenizer.decode(tokenizer('''Paris is the [MASK].''' ).input_ids )

        self.assertTrue(decoded_text == '''[CLS] Paris is the[MASK].[SEP]''' )


       @slow
       def _lowerCAmelCase(						self )  ->  Tuple:
        # fmt: off
        lowercase__				:    Union[str, Any]  =					{'''input_ids''': [[65, 39286, 458, 36335, 2001, 456, 13073, 13266, 455, 113, 7746, 1741, 11157, 391, 13073, 13266, 455, 113, 3967, 35412, 113, 4936, 109, 3870, 2377, 113, 30084, 45720, 458, 134, 17496, 112, 503, 11672, 113, 118, 112, 5665, 13347, 38687, 112, 1496, 31389, 112, 3268, 47264, 134, 962, 112, 16377, 8035, 23130, 430, 12169, 15518, 28592, 458, 146, 41697, 109, 391, 12169, 15518, 16689, 458, 146, 41358, 109, 452, 726, 4034, 111, 763, 35412, 5082, 388, 1903, 111, 9051, 391, 2870, 48918, 1900, 1123, 550, 998, 112, 9586, 15985, 455, 391, 410, 22955, 37636, 114, 66], [65, 448, 17496, 419, 3663, 385, 763, 113, 27533, 2870, 3283, 13043, 1639, 24713, 523, 656, 24013, 18550, 2521, 517, 27014, 21244, 420, 1212, 1465, 391, 927, 4833, 388, 578, 11786, 114, 66, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [65, 484, 2169, 7687, 21932, 18146, 726, 363, 17032, 3391, 114, 66, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], '''attention_mask''': [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]}  # noqa: E501
        # fmt: on

        self.tokenizer_integration_test_util(
            expected_encoding=__lowerCAmelCase	,   model_name='''google/bigbird-roberta-base'''	,   revision='''215c99f1600e06f83acce68422f2035b2b5c3510'''	,   )


'''simple docstring'''

def 			__UpperCamelCase       (   UpperCAmelCase     ):
 lowercase__				:    Optional[int]  =					1
 for i in range(1		,     num + 1     ):
  fact *= i
 return fact
def 			__UpperCamelCase       (   UpperCAmelCase     ):
 lowercase__				:    Optional[Any]  =					0
 while number > 0:
  lowercase__				:    str  =					number % 10
  sum_of_digits += last_digit
  lowercase__				:    List[str]  =					number // 10  # Removing the last_digit from the given number
 return sum_of_digits
def 			__UpperCamelCase       (   UpperCAmelCase = 100     ):
 lowercase__				:    Optional[int]  =					factorial(UpperCAmelCase     )
 lowercase__				:    Dict  =					split_and_add(UpperCAmelCase     )
 return result


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

