




'''simple docstring'''





from math import factorial





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

     """simple docstring"""




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


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








'''simple docstring'''





import argparse
import collections

import numpy as np
import torch
from flax import traverse_util
from tax import checkpoints

from transformers import MTaConfig, UMTaEncoderModel, UMTaForConditionalGeneration
from transformers.utils import logging


logging.set_verbosity_info()





def      __a     (       _UpperCamelCase:   Dict ,						_UpperCamelCase:   Optional[int] ,						_UpperCamelCase:   List[str]   )						->			Optional[Any]:

     """simple docstring"""




     return params[F"""{prefix}/{prefix}/relpos_bias/rel_embedding"""][:, i, :]





def      __a     (       _UpperCamelCase:   List[Any] ,						_UpperCamelCase:   Optional[Any] ,						_UpperCamelCase:   Dict ,						_UpperCamelCase:   Optional[Any]="attention"   )						->			Any:

     """simple docstring"""




     _snake_case							=				_snake_case							=				np.ascontiguousarray(params[F"""{prefix}/{prefix}/{layer_name}/key/kernel"""][:, i, :, :]   )
     _snake_case							=				k_tmp.reshape(k_tmp.shape[0] ,						k_tmp.shape[1] * k_tmp.shape[2]   )
     _snake_case							=				np.ascontiguousarray(params[F"""{prefix}/{prefix}/{layer_name}/out/kernel"""][:, i, :, :]   )
     _snake_case							=				o_tmp.reshape(o_tmp.shape[0] * o_tmp.shape[1] ,						o_tmp.shape[2]   )
     _snake_case							=				np.ascontiguousarray(params[F"""{prefix}/{prefix}/{layer_name}/query/kernel"""][:, i, :, :]   )
     _snake_case							=				q_tmp.reshape(q_tmp.shape[0] ,						q_tmp.shape[1] * q_tmp.shape[2]   )
     _snake_case							=				np.ascontiguousarray(params[F"""{prefix}/{prefix}/{layer_name}/value/kernel"""][:, i, :, :]   )
     _snake_case							=				v_tmp.reshape(v_tmp.shape[0] ,						v_tmp.shape[1] * v_tmp.shape[2]   )
     return k, o, q, v





def      __a     (       _UpperCamelCase:   Tuple ,						_UpperCamelCase:   Optional[int] ,						_UpperCamelCase:   Optional[int] ,						_UpperCamelCase:   Optional[int]=False   )						->			List[Any]:

     """simple docstring"""




     if split_mlp_wi:
          _snake_case							=				params[F"""{prefix}/{prefix}/mlp/wi_0/kernel"""][:, i, :]
          _snake_case							=				params[F"""{prefix}/{prefix}/mlp/wi_1/kernel"""][:, i, :]
          _snake_case							=				(wi_a, wi_a)
     else:
          _snake_case							=				params[F"""{prefix}/{prefix}/mlp/wi/kernel"""][:, i, :]

     _snake_case							=				params[F"""{prefix}/{prefix}/mlp/wo/kernel"""][:, i, :]
     return wi, wo





def      __a     (       _UpperCamelCase:   Optional[int] ,						_UpperCamelCase:   Dict ,						_UpperCamelCase:   Union[str, Any] ,						_UpperCamelCase:   Union[str, Any]   )						->			List[Any]:

     """simple docstring"""




     return params[F"""{prefix}/{prefix}/{layer_name}/scale"""][:, i]





def      __a     (       _UpperCamelCase:   dict ,						*, _UpperCamelCase:   int ,						_UpperCamelCase:   bool ,						_UpperCamelCase:   bool = False   )						->			str:

     """simple docstring"""




     _snake_case							=				traverse_util.flatten_dict(variables["target"]   )
     _snake_case							=				{"/".join(_UpperCamelCase   ): v for k, v in old.items()}

     # v1.1 models have a gated GeLU with wi_0 and wi_1 instead of wi
     _snake_case							=				"encoder/encoder/mlp/wi_0/kernel" in old
     print("Split MLP:" ,						_UpperCamelCase   )

     _snake_case							=				collections.OrderedDict()

     # Shared embeddings.
     _snake_case							=				old["token_embedder/embedding"]

     # Encoder.
     for i in range(_UpperCamelCase   ):
          # Block i, layer 0 (Self Attention).
          _snake_case							=				tax_layer_norm_lookup(_UpperCamelCase ,						_UpperCamelCase ,						"encoder" ,						"pre_attention_layer_norm"   )
          _snake_case							, _snake_case							, _snake_case							, _snake_case							=				tax_attention_lookup(_UpperCamelCase ,						_UpperCamelCase ,						"encoder" ,						"attention"   )
          _snake_case							=				layer_norm
          _snake_case							=				k.T
          _snake_case							=				o.T
          _snake_case							=				q.T
          _snake_case							=				v.T

          # Block i, layer 1 (MLP).
          _snake_case							=				tax_layer_norm_lookup(_UpperCamelCase ,						_UpperCamelCase ,						"encoder" ,						"pre_mlp_layer_norm"   )
          _snake_case							, _snake_case							=				tax_mlp_lookup(_UpperCamelCase ,						_UpperCamelCase ,						"encoder" ,						_UpperCamelCase   )
          _snake_case							=				layer_norm
          if split_mlp_wi:
               _snake_case							=				wi[0].T
               _snake_case							=				wi[1].T
          else:
               _snake_case							=				wi.T
          _snake_case							=				wo.T
          if scalable_attention:
               # convert the rel_embedding of each layer
               _snake_case							=				tax_relpos_bias_lookup(
                   _UpperCamelCase ,						_UpperCamelCase ,						"encoder"   ).T

     _snake_case							=				old["encoder/encoder_norm/scale"]

     if not scalable_attention:
          _snake_case							=				tax_relpos_bias_lookup(
              _UpperCamelCase ,						0 ,						"encoder"   ).T
          _snake_case							=				tax_relpos_bias_lookup(
              _UpperCamelCase ,						0 ,						"decoder"   ).T

     if not is_encoder_only:
          # Decoder.
          for i in range(_UpperCamelCase   ):
               # Block i, layer 0 (Self Attention).
               _snake_case							=				tax_layer_norm_lookup(_UpperCamelCase ,						_UpperCamelCase ,						"decoder" ,						"pre_self_attention_layer_norm"   )
               _snake_case							, _snake_case							, _snake_case							, _snake_case							=				tax_attention_lookup(_UpperCamelCase ,						_UpperCamelCase ,						"decoder" ,						"self_attention"   )
               _snake_case							=				layer_norm
               _snake_case							=				k.T
               _snake_case							=				o.T
               _snake_case							=				q.T
               _snake_case							=				v.T

               # Block i, layer 1 (Cross Attention).
               _snake_case							=				tax_layer_norm_lookup(_UpperCamelCase ,						_UpperCamelCase ,						"decoder" ,						"pre_cross_attention_layer_norm"   )
               _snake_case							, _snake_case							, _snake_case							, _snake_case							=				tax_attention_lookup(_UpperCamelCase ,						_UpperCamelCase ,						"decoder" ,						"encoder_decoder_attention"   )
               _snake_case							=				layer_norm
               _snake_case							=				k.T
               _snake_case							=				o.T
               _snake_case							=				q.T
               _snake_case							=				v.T

               # Block i, layer 2 (MLP).
               _snake_case							=				tax_layer_norm_lookup(_UpperCamelCase ,						_UpperCamelCase ,						"decoder" ,						"pre_mlp_layer_norm"   )
               _snake_case							, _snake_case							=				tax_mlp_lookup(_UpperCamelCase ,						_UpperCamelCase ,						"decoder" ,						_UpperCamelCase   )
               _snake_case							=				layer_norm
               if split_mlp_wi:
                    _snake_case							=				wi[0].T
                    _snake_case							=				wi[1].T
               else:
                    _snake_case							=				wi.T
               _snake_case							=				wo.T

               if scalable_attention:
                    # convert the rel_embedding of each layer
                    _snake_case							=				tax_relpos_bias_lookup(_UpperCamelCase ,						_UpperCamelCase ,						"decoder"   ).T

          _snake_case							=				old["decoder/decoder_norm/scale"]

          # LM Head (only in v1.1 checkpoints, in v1.0 embeddings are used instead)
          if "decoder/logits_dense/kernel" in old:
               _snake_case							=				old["decoder/logits_dense/kernel"].T

     return new





def      __a     (       _UpperCamelCase:   Any ,						_UpperCamelCase:   bool   )						->			Dict:

     """simple docstring"""




     _snake_case							=				collections.OrderedDict([(k, torch.from_numpy(v.copy()   )) for (k, v) in converted_params.items()]   )

     # Add what is missing.
     if "encoder.embed_tokens.weight" not in state_dict:
          _snake_case							=				state_dict["shared.weight"]

     if not is_encoder_only:
          if "decoder.embed_tokens.weight" not in state_dict:
               _snake_case							=				state_dict["shared.weight"]

          if "lm_head.weight" not in state_dict:  # For old 1.0 models.
               print("Using shared word embeddings as lm_head."   )
               _snake_case							=				state_dict["shared.weight"]

     return state_dict





def      __a     (       _UpperCamelCase:   str ,						_UpperCamelCase:   List[str] ,						_UpperCamelCase:   Any ,						_UpperCamelCase:   str ,						_UpperCamelCase:   List[Any]   )						->			Dict:

     """simple docstring"""




     _snake_case							=				checkpoints.load_tax_checkpoint(_UpperCamelCase   )
     _snake_case							=				convert_tax_to_pytorch(
         _UpperCamelCase ,						num_layers=config.num_layers ,						is_encoder_only=_UpperCamelCase ,						scalable_attention=_UpperCamelCase   )
     _snake_case							=				make_state_dict(_UpperCamelCase ,						_UpperCamelCase   )
     model.load_state_dict(_UpperCamelCase ,						strict=_UpperCamelCase   )





def      __a     (       _UpperCamelCase:   Union[str, Any] ,						_UpperCamelCase:   Union[str, Any] ,						_UpperCamelCase:   Optional[Any] ,						_UpperCamelCase:   bool = False ,						_UpperCamelCase:   bool = False ,						)						->			Dict:

     """simple docstring"""




     _snake_case							=				MTaConfig.from_json_file(_UpperCamelCase   )
     print(F"""Building PyTorch model from configuration: {config}"""   )
     # Non-v1.1 checkpoints could also use T5Model, but this works for all.
     # The v1.0 checkpoints will simply have an LM head that is the word embeddings.
     if is_encoder_only:
          _snake_case							=				UMTaEncoderModel(_UpperCamelCase   )
     else:
          _snake_case							=				UMTaForConditionalGeneration(_UpperCamelCase   )

     # Load weights from tf checkpoint
     load_tax_weights_in_ta(_UpperCamelCase ,						_UpperCamelCase ,						_UpperCamelCase ,						_UpperCamelCase ,						_UpperCamelCase   )

     # Save pytorch-model
     print(F"""Save PyTorch model to {pytorch_dump_path}"""   )
     model.save_pretrained(_UpperCamelCase   )

     # Verify that we can load the checkpoint.
     model.from_pretrained(_UpperCamelCase   )
     print("Done"   )


if __name__ == "__main__":
   UpperCamelCase_						:      Any       =						argparse.ArgumentParser(description='''Converts a native T5X checkpoint into a PyTorch checkpoint.''')
   # Required parameters
   parser.add_argument(
       '''--t5x_checkpoint_path''', default=None, type=str, required=True, help='''Path to the T5X checkpoint.'''
   )
   parser.add_argument(
       '''--config_file''',
       default=None,
       type=str,
       required=True,
       help='''The config json file corresponding to the pre-trained T5 model.\nThis specifies the model architecture.''',
   )
   parser.add_argument(
       '''--pytorch_dump_path''', default=None, type=str, required=True, help='''Path to the output PyTorch model.'''
   )
   parser.add_argument(
       '''--is_encoder_only''', action='''store_true''', help='''Check if the model is encoder-decoder model''', default=False
   )
   parser.add_argument(
       '''--scalable_attention''',
       action='''store_true''',
       help='''Whether the model uses scaled attention (umt5 model)''',
       default=False,
   )
   UpperCamelCase_						:      Union[str, Any]       =						parser.parse_args()
   convert_tax_checkpoint_to_pytorch(
       args.tax_checkpoint_path,
       args.config_file,
       args.pytorch_dump_path,
       args.is_encoder_only,
       args.scalable_attention,
   )


