




'''simple docstring'''





import copy
import inspect
import unittest

from transformers import AutoBackbone
from transformers.configuration_utils import PretrainedConfig
from transformers.testing_utils import require_timm, require_torch, torch_device
from transformers.utils.import_utils import is_torch_available

from ...test_backbone_common import BackboneTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor


if is_torch_available():
   import torch

   from transformers import TimmBackbone, TimmBackboneConfig

from ...test_pipeline_mixin import PipelineTesterMixin

class   _a							:






     def __init__(					self   ,_SCREAMING_SNAKE_CASE   ,_SCREAMING_SNAKE_CASE=None   ,_SCREAMING_SNAKE_CASE=None   ,_SCREAMING_SNAKE_CASE=None   ,_SCREAMING_SNAKE_CASE="resnet50"   ,_SCREAMING_SNAKE_CASE=3   ,_SCREAMING_SNAKE_CASE=32   ,_SCREAMING_SNAKE_CASE=3   ,_SCREAMING_SNAKE_CASE=True   ,_SCREAMING_SNAKE_CASE=True   ,)				->     Optional[Any]:
          _snake_case				= parent
          _snake_case				= out_indices if out_indices is not None else [4]
          _snake_case				= stage_names
          _snake_case				= out_features
          _snake_case				= backbone
          _snake_case				= batch_size
          _snake_case				= image_size
          _snake_case				= num_channels
          _snake_case				= use_pretrained_backbone
          _snake_case				= is_training






     def 							_lowercase      (					self       )				->     Optional[int]:
          _snake_case				= floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]       )
          _snake_case				= self.get_config()

          return config, pixel_values






     def 							_lowercase      (					self       )				->     Tuple:
          return TimmBackboneConfig(
              image_size=self.image_size   ,num_channels=self.num_channels   ,out_features=self.out_features   ,out_indices=self.out_indices   ,stage_names=self.stage_names   ,use_pretrained_backbone=self.use_pretrained_backbone   ,backbone=self.backbone   ,)






     def 							_lowercase      (					self   ,_SCREAMING_SNAKE_CASE   ,_SCREAMING_SNAKE_CASE       )				->     Union[str, Any]:
          _snake_case				= TimmBackbone(config=_SCREAMING_SNAKE_CASE       )
          model.to(_SCREAMING_SNAKE_CASE       )
          model.eval()
          with torch.no_grad():
               _snake_case				= model(_SCREAMING_SNAKE_CASE       )
          self.parent.assertEqual(
              result.feature_map[-1].shape   ,(self.batch_size, model.channels[-1], 14, 14)   ,)






     def 							_lowercase      (					self       )				->     Tuple:
          _snake_case				= self.prepare_config_and_inputs()
          _snake_case				,   _snake_case				= config_and_inputs
          _snake_case				= {"pixel_values": pixel_values}
          return config, inputs_dict







@require_torch
@require_timm
class   _a							(		__lowerCAmelCase   ,   __lowerCAmelCase   ,   __lowerCAmelCase   ,   unittest.TestCase				):
     SCREAMING_SNAKE_CASE_				:       Optional[int]       							=		(TimmBackbone,) if is_torch_available() else ()
     SCREAMING_SNAKE_CASE_				:       List[Any]       							=		{"""feature-extraction""": TimmBackbone} if is_torch_available() else {}
     SCREAMING_SNAKE_CASE_				:       Tuple       							=		False
     SCREAMING_SNAKE_CASE_				:       List[str]       							=		False
     SCREAMING_SNAKE_CASE_				:       Tuple       							=		False
     SCREAMING_SNAKE_CASE_				:       Optional[int]       							=		False






     def 							_lowercase      (					self       )				->     int:
          _snake_case				= TimmBackboneModelTester(self       )
          _snake_case				= ConfigTester(self   ,config_class=_SCREAMING_SNAKE_CASE   ,has_text_modality=_SCREAMING_SNAKE_CASE       )






     def 							_lowercase      (					self       )				->     Tuple:
          self.config_tester.create_and_test_config_to_json_string()
          self.config_tester.create_and_test_config_to_json_file()
          self.config_tester.create_and_test_config_from_and_save_pretrained()
          self.config_tester.create_and_test_config_with_num_labels()
          self.config_tester.check_config_can_be_init_without_params()
          self.config_tester.check_config_arguments_init()






     def 							_lowercase      (					self       )				->     List[Any]:
          _snake_case				= "resnet18"
          _snake_case				= "microsoft/resnet-18"

          _snake_case				= AutoBackbone.from_pretrained(_SCREAMING_SNAKE_CASE   ,use_timm_backbone=_SCREAMING_SNAKE_CASE       )
          _snake_case				= AutoBackbone.from_pretrained(_SCREAMING_SNAKE_CASE       )

          self.assertEqual(len(timm_model.out_features       )   ,len(transformers_model.out_features       )       )
          self.assertEqual(len(timm_model.stage_names       )   ,len(transformers_model.stage_names       )       )
          self.assertEqual(timm_model.channels   ,transformers_model.channels       )
          # Out indices are set to the last layer by default. For timm models, we don't know
          # the number of layers in advance, so we set it to (-1,), whereas for transformers
          # models, we set it to [len(stage_names) - 1] (kept for backward compatibility).
          self.assertEqual(timm_model.out_indices   ,(-1,)       )
          self.assertEqual(transformers_model.out_indices   ,[len(timm_model.stage_names       ) - 1]       )

          _snake_case				= AutoBackbone.from_pretrained(_SCREAMING_SNAKE_CASE   ,use_timm_backbone=_SCREAMING_SNAKE_CASE   ,out_indices=[1, 2, 3]       )
          _snake_case				= AutoBackbone.from_pretrained(_SCREAMING_SNAKE_CASE   ,out_indices=[1, 2, 3]       )

          self.assertEqual(timm_model.out_indices   ,transformers_model.out_indices       )
          self.assertEqual(len(timm_model.out_features       )   ,len(transformers_model.out_features       )       )
          self.assertEqual(timm_model.channels   ,transformers_model.channels       )






     @unittest.skip("TimmBackbone doesn't support feed forward chunking"       )
     def 							_lowercase      (					self       )				->     Optional[int]:
          pass






     @unittest.skip("TimmBackbone doesn't have num_hidden_layers attribute"       )
     def 							_lowercase      (					self       )				->     int:
          pass






     @unittest.skip("TimmBackbone initialization is managed on the timm side"       )
     def 							_lowercase      (					self       )				->     Union[str, Any]:
          pass






     @unittest.skip("TimmBackbone models doesn't have inputs_embeds"       )
     def 							_lowercase      (					self       )				->     Any:
          pass






     @unittest.skip("TimmBackbone models doesn't have inputs_embeds"       )
     def 							_lowercase      (					self       )				->     Union[str, Any]:
          pass






     @unittest.skip("TimmBackbone model cannot be created without specifying a backbone checkpoint"       )
     def 							_lowercase      (					self       )				->     Optional[Any]:
          pass






     @unittest.skip("Only checkpoints on timm can be loaded into TimmBackbone"       )
     def 							_lowercase      (					self       )				->     List[Any]:
          pass






     @unittest.skip("model weights aren't tied in TimmBackbone."       )
     def 							_lowercase      (					self       )				->     int:
          pass






     @unittest.skip("model weights aren't tied in TimmBackbone."       )
     def 							_lowercase      (					self       )				->     Dict:
          pass






     @unittest.skip("Only checkpoints on timm can be loaded into TimmBackbone"       )
     def 							_lowercase      (					self       )				->     Any:
          pass






     @unittest.skip("Only checkpoints on timm can be loaded into TimmBackbone"       )
     def 							_lowercase      (					self       )				->     Tuple:
          pass






     @unittest.skip("TimmBackbone doesn't have hidden size info in its configuration."       )
     def 							_lowercase      (					self       )				->     int:
          pass






     @unittest.skip("TimmBackbone doesn't support output_attentions."       )
     def 							_lowercase      (					self       )				->     Tuple:
          pass






     @unittest.skip("Safetensors is not supported by timm."       )
     def 							_lowercase      (					self       )				->     List[Any]:
          pass






     @unittest.skip("Will be fixed soon by reducing the size of the model used for common tests."       )
     def 							_lowercase      (					self       )				->     int:
          pass






     def 							_lowercase      (					self       )				->     int:
          _snake_case				,   _snake_case				= self.model_tester.prepare_config_and_inputs_for_common()

          for model_class in self.all_model_classes:
               _snake_case				= model_class(_SCREAMING_SNAKE_CASE       )
               _snake_case				= inspect.signature(model.forward       )
               # signature.parameters is an OrderedDict => so arg_names order is deterministic
               _snake_case				= [*signature.parameters.keys()]

               _snake_case				= ["pixel_values"]
               self.assertListEqual(arg_names[:1]   ,_SCREAMING_SNAKE_CASE       )






     def 							_lowercase      (					self       )				->     Tuple:
          _snake_case				,   _snake_case				= self.model_tester.prepare_config_and_inputs_for_common()
          _snake_case				= True
          _snake_case				= self.has_attentions

          # no need to test all models as different heads yield the same functionality
          _snake_case				= self.all_model_classes[0]
          _snake_case				= model_class(_SCREAMING_SNAKE_CASE       )
          model.to(_SCREAMING_SNAKE_CASE       )

          _snake_case				= self._prepare_for_class(_SCREAMING_SNAKE_CASE   ,_SCREAMING_SNAKE_CASE       )
          _snake_case				= model(**_SCREAMING_SNAKE_CASE       )
          _snake_case				= outputs[0][-1]

          # Encoder-/Decoder-only models
          _snake_case				= outputs.hidden_states[0]
          hidden_states.retain_grad()

          if self.has_attentions:
               _snake_case				= outputs.attentions[0]
               attentions.retain_grad()

          output.flatten()[0].backward(retain_graph=_SCREAMING_SNAKE_CASE       )

          self.assertIsNotNone(hidden_states.grad       )

          if self.has_attentions:
               self.assertIsNotNone(attentions.grad       )






     def 							_lowercase      (					self       )				->     Union[str, Any]:
          _snake_case				,   _snake_case				= self.model_tester.prepare_config_and_inputs_for_common()

          for model_class in self.all_model_classes:
               _snake_case				= model_class(_SCREAMING_SNAKE_CASE       )
               model.to(_SCREAMING_SNAKE_CASE       )
               model.eval()
               _snake_case				= model(**_SCREAMING_SNAKE_CASE       )

               self.assertEqual(len(result.feature_maps       )   ,len(config.out_indices       )       )
               self.assertEqual(len(model.channels       )   ,len(config.out_indices       )       )

               # Check output of last stage is taken if out_features=None, out_indices=None
               _snake_case				= copy.deepcopy(_SCREAMING_SNAKE_CASE       )
               _snake_case				= None
               _snake_case				= model_class(_SCREAMING_SNAKE_CASE       )
               model.to(_SCREAMING_SNAKE_CASE       )
               model.eval()
               _snake_case				= model(**_SCREAMING_SNAKE_CASE       )

               self.assertEqual(len(result.feature_maps       )   ,1       )
               self.assertEqual(len(model.channels       )   ,1       )

               # Check backbone can be initialized with fresh weights
               _snake_case				= copy.deepcopy(_SCREAMING_SNAKE_CASE       )
               _snake_case				= False
               _snake_case				= model_class(_SCREAMING_SNAKE_CASE       )
               model.to(_SCREAMING_SNAKE_CASE       )
               model.eval()
               _snake_case				= model(**_SCREAMING_SNAKE_CASE       )








'''simple docstring'''





from math import factorial





def       __a      (  _UpperCamelCase:       int = 100       )		->					int:

     """simple docstring"""




     return sum(map(_UpperCamelCase   ,		str(factorial(_UpperCamelCase       )       )       )       )


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


