






'''simple docstring'''
import os
import shutil
import sys
import tempfile
import unittest
from pathlib import Path

import pytest

import transformers
from transformers import (
    BERT_PRETRAINED_CONFIG_ARCHIVE_MAP,
    GPT2_PRETRAINED_CONFIG_ARCHIVE_MAP,
    AutoTokenizer,
    BertConfig,
    BertTokenizer,
    BertTokenizerFast,
    CTRLTokenizer,
    GPTaTokenizer,
    GPTaTokenizerFast,
    PreTrainedTokenizerFast,
    RobertaTokenizer,
    RobertaTokenizerFast,
    is_tokenizers_available,
)
from transformers.models.auto.configuration_auto import CONFIG_MAPPING, AutoConfig
from transformers.models.auto.tokenization_auto import (
    TOKENIZER_MAPPING,
    get_tokenizer_config,
    tokenizer_class_from_name,
)
from transformers.models.roberta.configuration_roberta import RobertaConfig
from transformers.testing_utils import (
    DUMMY_DIFF_TOKENIZER_IDENTIFIER,
    DUMMY_UNKNOWN_IDENTIFIER,
    SMALL_MODEL_IDENTIFIER,
    RequestCounter,
    require_tokenizers,
    slow,
)


sys.path.append(str(Path(__file__).parent.parent.parent.parent / 'utils'))

from test_module.custom_configuration import CustomConfig  # noqa E402
from test_module.custom_tokenization import CustomTokenizer  # noqa E402


if is_tokenizers_available():
      from test_module.custom_tokenization_fast import CustomTokenizerFast






class        __SCREAMING_SNAKE_CASE (     unittest.TestCase			):




 def        __magic_name__		( self		:							Tuple )		->  List[str]:
       SCREAMING_SNAKE_CASE__       :			Optional[Any]													=0




 @slow
 def        __magic_name__		( self		:							Union[str, Any] )		->  Union[str, Any]:
       for model_name in (x for x in BERT_PRETRAINED_CONFIG_ARCHIVE_MAP.keys() if "japanese" not in x):
             SCREAMING_SNAKE_CASE__       :			Union[str, Any]													=AutoTokenizer.from_pretrained(__lowercase )
             self.assertIsNotNone(__lowercase )
             self.assertIsInstance(__lowercase   , (BertTokenizer, BertTokenizerFast) )
             self.assertGreater(len(__lowercase )   , 0 )

       for model_name in GPT2_PRETRAINED_CONFIG_ARCHIVE_MAP.keys():
             SCREAMING_SNAKE_CASE__       :			int													=AutoTokenizer.from_pretrained(__lowercase )
             self.assertIsNotNone(__lowercase )
             self.assertIsInstance(__lowercase   , (GPTaTokenizer, GPTaTokenizerFast) )
             self.assertGreater(len(__lowercase )   , 0 )




 def        __magic_name__		( self		:							Tuple )		->  Tuple:
       SCREAMING_SNAKE_CASE__       :			Tuple													=AutoTokenizer.from_pretrained(__lowercase )
       self.assertIsInstance(__lowercase   , (BertTokenizer, BertTokenizerFast) )
       self.assertEqual(tokenizer.vocab_size   , 12 )




 def        __magic_name__		( self		:							Optional[Any] )		->  Optional[int]:
       SCREAMING_SNAKE_CASE__       :			List[Any]													=AutoTokenizer.from_pretrained(__lowercase )
       self.assertIsInstance(__lowercase   , (RobertaTokenizer, RobertaTokenizerFast) )
       self.assertEqual(tokenizer.vocab_size   , 20 )




 def        __magic_name__		( self		:							Any )		->  Any:
       SCREAMING_SNAKE_CASE__       :			List[str]													=AutoConfig.from_pretrained(__lowercase )
       self.assertIsInstance(__lowercase   , __lowercase )
       # Check that tokenizer_type ≠ model_type
       SCREAMING_SNAKE_CASE__       :			Optional[Any]													=AutoTokenizer.from_pretrained(__lowercase   , config=__lowercase )
       self.assertIsInstance(__lowercase   , (BertTokenizer, BertTokenizerFast) )
       self.assertEqual(tokenizer.vocab_size   , 12 )




 def        __magic_name__		( self		:							Optional[int] )		->  List[str]:
       with tempfile.TemporaryDirectory() as tmp_dir:
             shutil.copy('''./tests/fixtures/vocab.txt'''   , os.path.join(__lowercase   , '''vocab.txt''' ) )

             SCREAMING_SNAKE_CASE__       :			List[Any]													=AutoTokenizer.from_pretrained(__lowercase   , tokenizer_type='''bert'''   , use_fast=__lowercase )
             self.assertIsInstance(__lowercase   , __lowercase )

       with tempfile.TemporaryDirectory() as tmp_dir:
             shutil.copy('''./tests/fixtures/vocab.json'''   , os.path.join(__lowercase   , '''vocab.json''' ) )
             shutil.copy('''./tests/fixtures/merges.txt'''   , os.path.join(__lowercase   , '''merges.txt''' ) )

             SCREAMING_SNAKE_CASE__       :			Optional[Any]													=AutoTokenizer.from_pretrained(__lowercase   , tokenizer_type='''gpt2'''   , use_fast=__lowercase )
             self.assertIsInstance(__lowercase   , __lowercase )




 @require_tokenizers
 def        __magic_name__		( self		:							Tuple )		->  Optional[int]:
       with tempfile.TemporaryDirectory() as tmp_dir:
             shutil.copy('''./tests/fixtures/vocab.txt'''   , os.path.join(__lowercase   , '''vocab.txt''' ) )

             SCREAMING_SNAKE_CASE__       :			List[Any]													=AutoTokenizer.from_pretrained(__lowercase   , tokenizer_type='''bert''' )
             self.assertIsInstance(__lowercase   , __lowercase )

       with tempfile.TemporaryDirectory() as tmp_dir:
             shutil.copy('''./tests/fixtures/vocab.json'''   , os.path.join(__lowercase   , '''vocab.json''' ) )
             shutil.copy('''./tests/fixtures/merges.txt'''   , os.path.join(__lowercase   , '''merges.txt''' ) )

             SCREAMING_SNAKE_CASE__       :			Any													=AutoTokenizer.from_pretrained(__lowercase   , tokenizer_type='''gpt2''' )
             self.assertIsInstance(__lowercase   , __lowercase )




 def        __magic_name__		( self		:							Optional[int] )		->  int:
       with pytest.raises(__lowercase ):
             AutoTokenizer.from_pretrained('''./'''   , tokenizer_type='''xxx''' )




 @require_tokenizers
 def        __magic_name__		( self		:							Union[str, Any] )		->  Dict:
       for tokenizer_class in [BertTokenizer, BertTokenizerFast, AutoTokenizer]:
             SCREAMING_SNAKE_CASE__       :			List[Any]													=tokenizer_class.from_pretrained('''wietsedv/bert-base-dutch-cased''' )
             self.assertIsInstance(__lowercase   , (BertTokenizer, BertTokenizerFast) )

             if isinstance(__lowercase   , __lowercase ):
                   self.assertEqual(tokenizer.basic_tokenizer.do_lower_case   , __lowercase )
             else:
                   self.assertEqual(tokenizer.do_lower_case   , __lowercase )

             self.assertEqual(tokenizer.model_max_length   , 5_12 )




 @require_tokenizers
 def        __magic_name__		( self		:							str )		->  List[str]:
       for tokenizer_class in [BertTokenizer, BertTokenizerFast, AutoTokenizer]:
             with self.assertRaisesRegex(
                 __lowercase   , '''julien-c/herlolip-not-exists is not a local folder and is not a valid model identifier'''   , ):
                   SCREAMING_SNAKE_CASE__       :			Optional[int]													=tokenizer_class.from_pretrained('''julien-c/herlolip-not-exists''' )




 def        __magic_name__		( self		:							Union[str, Any] )		->  List[Any]:
       # tests: https://github.com/huggingface/transformers/pull/13251
       # 1. models with `-`, e.g. xlm-roberta -> xlm_roberta
       # 2. models that don't remap 1-1 from model-name to model file, e.g., openai-gpt -> openai
       SCREAMING_SNAKE_CASE__       :			Tuple													=TOKENIZER_MAPPING.values()
       SCREAMING_SNAKE_CASE__       :			int													=[]

       for slow_tok, fast_tok in tokenizers:
             if slow_tok is not None:
                   tokenizer_names.append(slow_tok.__name__ )

             if fast_tok is not None:
                   tokenizer_names.append(fast_tok.__name__ )

       for tokenizer_name in tokenizer_names:
             # must find the right class
             tokenizer_class_from_name(__lowercase )




 @require_tokenizers
 def        __magic_name__		( self		:							List[str] )		->  Union[str, Any]:
       self.assertIsInstance(AutoTokenizer.from_pretrained('''bert-base-cased'''   , use_fast=__lowercase )   , __lowercase )
       self.assertIsInstance(AutoTokenizer.from_pretrained('''bert-base-cased''' )   , __lowercase )




 @require_tokenizers
 def        __magic_name__		( self		:							List[str] )		->  List[str]:
       SCREAMING_SNAKE_CASE__       :			List[Any]													=AutoTokenizer.from_pretrained('''distilbert-base-uncased'''   , do_lower_case=__lowercase )
       SCREAMING_SNAKE_CASE__       :			str													='''Hello, world. How are you?'''
       SCREAMING_SNAKE_CASE__       :			str													=tokenizer.tokenize(__lowercase )
       self.assertEqual('''[UNK]'''   , tokens[0] )

       SCREAMING_SNAKE_CASE__       :			Optional[Any]													=AutoTokenizer.from_pretrained('''microsoft/mpnet-base'''   , do_lower_case=__lowercase )
       SCREAMING_SNAKE_CASE__       :			Optional[int]													=tokenizer.tokenize(__lowercase )
       self.assertEqual('''[UNK]'''   , tokens[0] )




 @require_tokenizers
 def        __magic_name__		( self		:							Dict )		->  Any:
       SCREAMING_SNAKE_CASE__       :			List[str]													=AutoTokenizer.from_pretrained('''robot-test/dummy-tokenizer-fast-with-model-config''' )
       self.assertEqual(type(__lowercase )   , __lowercase )
       self.assertEqual(tokenizer.model_max_length   , 5_12 )
       self.assertEqual(tokenizer.vocab_size   , 3_00_00 )
       self.assertEqual(tokenizer.unk_token   , '''[UNK]''' )
       self.assertEqual(tokenizer.padding_side   , '''right''' )
       self.assertEqual(tokenizer.truncation_side   , '''right''' )




 def        __magic_name__		( self		:							Optional[Any] )		->  Optional[int]:
       SCREAMING_SNAKE_CASE__       :			Optional[Any]													=AutoTokenizer.from_pretrained(__lowercase )
       self.assertIsInstance(__lowercase   , (BertTokenizer, BertTokenizerFast) )
       with tempfile.TemporaryDirectory() as tmp_dir:
             tokenizer.save_pretrained(__lowercase )
             SCREAMING_SNAKE_CASE__       :			Optional[Any]													=AutoTokenizer.from_pretrained(__lowercase )

       self.assertIsInstance(__lowercase   , tokenizer.__class__ )
       self.assertEqual(tokenizera.vocab_size   , 12 )




 def        __magic_name__		( self		:							List[Any] )		->  List[str]:
       SCREAMING_SNAKE_CASE__       :			Union[str, Any]													=AutoTokenizer.from_pretrained('''ctrl''' )
       # There is no fast CTRL so this always gives us a slow tokenizer.
       self.assertIsInstance(__lowercase   , __lowercase )




 def        __magic_name__		( self		:							str )		->  List[str]:
       # Check we can load the tokenizer config of an online model.
       SCREAMING_SNAKE_CASE__       :			Optional[Any]													=get_tokenizer_config('''bert-base-cased''' )
       SCREAMING_SNAKE_CASE__       :			List[Any]													=config.pop('''_commit_hash'''   , __lowercase )
       # If we ever update bert-base-cased tokenizer config, this dict here will need to be updated.
       self.assertEqual(__lowercase   , {'''do_lower_case''': False} )

       # This model does not have a tokenizer_config so we get back an empty dict.
       SCREAMING_SNAKE_CASE__       :			str													=get_tokenizer_config(__lowercase )
       self.assertDictEqual(__lowercase   , {} )

       # A tokenizer saved with `save_pretrained` always creates a tokenizer config.
       SCREAMING_SNAKE_CASE__       :			int													=AutoTokenizer.from_pretrained(__lowercase )
       with tempfile.TemporaryDirectory() as tmp_dir:
             tokenizer.save_pretrained(__lowercase )
             SCREAMING_SNAKE_CASE__       :			Any													=get_tokenizer_config(__lowercase )

       # Check the class of the tokenizer was properly saved (note that it always saves the slow class).
       self.assertEqual(config['''tokenizer_class''']   , '''BertTokenizer''' )




 def        __magic_name__		( self		:							Any )		->  Tuple:
       try:
             AutoConfig.register('''custom'''   , __lowercase )

             AutoTokenizer.register(__lowercase   , slow_tokenizer_class=__lowercase )
             # Trying to register something existing in the Transformers library will raise an error
             with self.assertRaises(__lowercase ):
                   AutoTokenizer.register(__lowercase   , slow_tokenizer_class=__lowercase )

             SCREAMING_SNAKE_CASE__       :			Union[str, Any]													=CustomTokenizer.from_pretrained(__lowercase )
             with tempfile.TemporaryDirectory() as tmp_dir:
                   tokenizer.save_pretrained(__lowercase )

                   SCREAMING_SNAKE_CASE__       :			Optional[int]													=AutoTokenizer.from_pretrained(__lowercase )
                   self.assertIsInstance(__lowercase   , __lowercase )

       finally:
             if "custom" in CONFIG_MAPPING._extra_content:
                   del CONFIG_MAPPING._extra_content["custom"]
             if CustomConfig in TOKENIZER_MAPPING._extra_content:
                   del TOKENIZER_MAPPING._extra_content[CustomConfig]




 @require_tokenizers
 def        __magic_name__		( self		:							int )		->  Any:
       try:
             AutoConfig.register('''custom'''   , __lowercase )

             # Can register in two steps
             AutoTokenizer.register(__lowercase   , slow_tokenizer_class=__lowercase )
             self.assertEqual(TOKENIZER_MAPPING[CustomConfig]   , (CustomTokenizer, None) )
             AutoTokenizer.register(__lowercase   , fast_tokenizer_class=__lowercase )
             self.assertEqual(TOKENIZER_MAPPING[CustomConfig]   , (CustomTokenizer, CustomTokenizerFast) )

             del TOKENIZER_MAPPING._extra_content[CustomConfig]
             # Can register in one step
             AutoTokenizer.register(
                 __lowercase   , slow_tokenizer_class=__lowercase   , fast_tokenizer_class=__lowercase )
             self.assertEqual(TOKENIZER_MAPPING[CustomConfig]   , (CustomTokenizer, CustomTokenizerFast) )

             # Trying to register something existing in the Transformers library will raise an error
             with self.assertRaises(__lowercase ):
                   AutoTokenizer.register(__lowercase   , fast_tokenizer_class=__lowercase )

             # We pass through a bert tokenizer fast cause there is no converter slow to fast for our new toknizer
             # and that model does not have a tokenizer.json
             with tempfile.TemporaryDirectory() as tmp_dir:
                   SCREAMING_SNAKE_CASE__       :			str													=BertTokenizerFast.from_pretrained(__lowercase )
                   bert_tokenizer.save_pretrained(__lowercase )
                   SCREAMING_SNAKE_CASE__       :			Any													=CustomTokenizerFast.from_pretrained(__lowercase )

             with tempfile.TemporaryDirectory() as tmp_dir:
                   tokenizer.save_pretrained(__lowercase )

                   SCREAMING_SNAKE_CASE__       :			Optional[Any]													=AutoTokenizer.from_pretrained(__lowercase )
                   self.assertIsInstance(__lowercase   , __lowercase )

                   SCREAMING_SNAKE_CASE__       :			List[Any]													=AutoTokenizer.from_pretrained(__lowercase   , use_fast=__lowercase )
                   self.assertIsInstance(__lowercase   , __lowercase )

       finally:
             if "custom" in CONFIG_MAPPING._extra_content:
                   del CONFIG_MAPPING._extra_content["custom"]
             if CustomConfig in TOKENIZER_MAPPING._extra_content:
                   del TOKENIZER_MAPPING._extra_content[CustomConfig]




 def        __magic_name__		( self		:							Union[str, Any] )		->  Tuple:
       # If remote code is not set, we will time out when asking whether to load the model.
       with self.assertRaises(__lowercase ):
             SCREAMING_SNAKE_CASE__       :			int													=AutoTokenizer.from_pretrained('''hf-internal-testing/test_dynamic_tokenizer''' )
       # If remote code is disabled, we can't load this config.
       with self.assertRaises(__lowercase ):
             SCREAMING_SNAKE_CASE__       :			Optional[int]													=AutoTokenizer.from_pretrained(
                 '''hf-internal-testing/test_dynamic_tokenizer'''   , trust_remote_code=__lowercase )

       SCREAMING_SNAKE_CASE__       :			Optional[Any]													=AutoTokenizer.from_pretrained('''hf-internal-testing/test_dynamic_tokenizer'''   , trust_remote_code=__lowercase )
       self.assertTrue(tokenizer.special_attribute_present )
       # Test tokenizer can be reloaded.
       with tempfile.TemporaryDirectory() as tmp_dir:
             tokenizer.save_pretrained(__lowercase )
             SCREAMING_SNAKE_CASE__       :			Dict													=AutoTokenizer.from_pretrained(__lowercase   , trust_remote_code=__lowercase )
       self.assertTrue(reloaded_tokenizer.special_attribute_present )

       if is_tokenizers_available():
             self.assertEqual(tokenizer.__class__.__name__   , '''NewTokenizerFast''' )
             self.assertEqual(reloaded_tokenizer.__class__.__name__   , '''NewTokenizerFast''' )

             # Test we can also load the slow version
             SCREAMING_SNAKE_CASE__       :			str													=AutoTokenizer.from_pretrained(
                 '''hf-internal-testing/test_dynamic_tokenizer'''   , trust_remote_code=__lowercase   , use_fast=__lowercase )
             self.assertTrue(tokenizer.special_attribute_present )
             self.assertEqual(tokenizer.__class__.__name__   , '''NewTokenizer''' )
             # Test tokenizer can be reloaded.
             with tempfile.TemporaryDirectory() as tmp_dir:
                   tokenizer.save_pretrained(__lowercase )
                   SCREAMING_SNAKE_CASE__       :			Optional[Any]													=AutoTokenizer.from_pretrained(__lowercase   , trust_remote_code=__lowercase   , use_fast=__lowercase )
             self.assertEqual(reloaded_tokenizer.__class__.__name__   , '''NewTokenizer''' )
             self.assertTrue(reloaded_tokenizer.special_attribute_present )
       else:
             self.assertEqual(tokenizer.__class__.__name__   , '''NewTokenizer''' )
             self.assertEqual(reloaded_tokenizer.__class__.__name__   , '''NewTokenizer''' )




 @require_tokenizers
 def        __magic_name__		( self		:							Any )		->  Optional[int]:






       class        __SCREAMING_SNAKE_CASE (     lowerCamelCase			):
        snake_case_												=							False






       class        __SCREAMING_SNAKE_CASE (     lowerCamelCase			):
        snake_case_												=							NewTokenizer
        snake_case_												=							False

       try:
             AutoConfig.register('''custom'''   , __lowercase )
             AutoTokenizer.register(__lowercase   , slow_tokenizer_class=__lowercase )
             AutoTokenizer.register(__lowercase   , fast_tokenizer_class=__lowercase )
             # If remote code is not set, the default is to use local
             SCREAMING_SNAKE_CASE__       :			Optional[Any]													=AutoTokenizer.from_pretrained('''hf-internal-testing/test_dynamic_tokenizer''' )
             self.assertEqual(tokenizer.__class__.__name__   , '''NewTokenizerFast''' )
             self.assertFalse(tokenizer.special_attribute_present )
             SCREAMING_SNAKE_CASE__       :			Optional[int]													=AutoTokenizer.from_pretrained('''hf-internal-testing/test_dynamic_tokenizer'''   , use_fast=__lowercase )
             self.assertEqual(tokenizer.__class__.__name__   , '''NewTokenizer''' )
             self.assertFalse(tokenizer.special_attribute_present )

             # If remote code is disabled, we load the local one.
             SCREAMING_SNAKE_CASE__       :			List[str]													=AutoTokenizer.from_pretrained(
                 '''hf-internal-testing/test_dynamic_tokenizer'''   , trust_remote_code=__lowercase )
             self.assertEqual(tokenizer.__class__.__name__   , '''NewTokenizerFast''' )
             self.assertFalse(tokenizer.special_attribute_present )
             SCREAMING_SNAKE_CASE__       :			Dict													=AutoTokenizer.from_pretrained(
                 '''hf-internal-testing/test_dynamic_tokenizer'''   , trust_remote_code=__lowercase   , use_fast=__lowercase )
             self.assertEqual(tokenizer.__class__.__name__   , '''NewTokenizer''' )
             self.assertFalse(tokenizer.special_attribute_present )

             # If remote is enabled, we load from the Hub
             SCREAMING_SNAKE_CASE__       :			int													=AutoTokenizer.from_pretrained(
                 '''hf-internal-testing/test_dynamic_tokenizer'''   , trust_remote_code=__lowercase )
             self.assertEqual(tokenizer.__class__.__name__   , '''NewTokenizerFast''' )
             self.assertTrue(tokenizer.special_attribute_present )
             SCREAMING_SNAKE_CASE__       :			Tuple													=AutoTokenizer.from_pretrained(
                 '''hf-internal-testing/test_dynamic_tokenizer'''   , trust_remote_code=__lowercase   , use_fast=__lowercase )
             self.assertEqual(tokenizer.__class__.__name__   , '''NewTokenizer''' )
             self.assertTrue(tokenizer.special_attribute_present )

       finally:
             if "custom" in CONFIG_MAPPING._extra_content:
                   del CONFIG_MAPPING._extra_content["custom"]
             if CustomConfig in TOKENIZER_MAPPING._extra_content:
                   del TOKENIZER_MAPPING._extra_content[CustomConfig]




 def        __magic_name__		( self		:							Tuple )		->  Union[str, Any]:
       SCREAMING_SNAKE_CASE__       :			str													=AutoTokenizer.from_pretrained(
           '''hf-internal-testing/test_dynamic_tokenizer_legacy'''   , trust_remote_code=__lowercase )
       self.assertTrue(tokenizer.special_attribute_present )
       if is_tokenizers_available():
             self.assertEqual(tokenizer.__class__.__name__   , '''NewTokenizerFast''' )

             # Test we can also load the slow version
             SCREAMING_SNAKE_CASE__       :			List[str]													=AutoTokenizer.from_pretrained(
                 '''hf-internal-testing/test_dynamic_tokenizer_legacy'''   , trust_remote_code=__lowercase   , use_fast=__lowercase )
             self.assertTrue(tokenizer.special_attribute_present )
             self.assertEqual(tokenizer.__class__.__name__   , '''NewTokenizer''' )
       else:
             self.assertEqual(tokenizer.__class__.__name__   , '''NewTokenizer''' )




 def        __magic_name__		( self		:							List[str] )		->  Any:
       with self.assertRaisesRegex(
           __lowercase   , '''bert-base is not a local folder and is not a valid model identifier''' ):
             SCREAMING_SNAKE_CASE__       :			Optional[int]													=AutoTokenizer.from_pretrained('''bert-base''' )




 def        __magic_name__		( self		:							Optional[int] )		->  Union[str, Any]:
       with self.assertRaisesRegex(
           __lowercase   , r'''aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)''' ):
             SCREAMING_SNAKE_CASE__       :			Dict													=AutoTokenizer.from_pretrained(__lowercase   , revision='''aaaaaa''' )




 def        __magic_name__		( self		:							Union[str, Any] )		->  Union[str, Any]:
       # Make sure we have cached the tokenizer.
       SCREAMING_SNAKE_CASE__       :			Optional[Any]													=AutoTokenizer.from_pretrained('''hf-internal-testing/tiny-random-bert''' )
       with RequestCounter() as counter:
             SCREAMING_SNAKE_CASE__       :			Any													=AutoTokenizer.from_pretrained('''hf-internal-testing/tiny-random-bert''' )
             self.assertEqual(counter.get_request_count   , 0 )
             self.assertEqual(counter.head_request_count   , 1 )
             self.assertEqual(counter.other_request_count   , 0 )







'''simple docstring'''
from math import factorial





def 	_a(					UpperCamelCase__			:  int = 1_0_0							):




      '''simple docstring'''






      return sum(int(UpperCamelCase__							) for x in str(factorial(UpperCamelCase__							)							)							)


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