


"""simple docstring"""
import argparse

import torch
from huggingface_hub import hf_hub_download

from transformers import AutoTokenizer, RobertaPreLayerNormConfig, RobertaPreLayerNormForMaskedLM
from transformers.utils import logging


logging.set_verbosity_info()
__SCREAMING_SNAKE_CASE							:    int		=    logging.get_logger(__name__)







def 						_a				(      _SCREAMING_SNAKE_CASE				, _SCREAMING_SNAKE_CASE				)    ->				Dict:
							snake_case_           =		RobertaPreLayerNormConfig.from_pretrained(
							    _SCREAMING_SNAKE_CASE				, architectures=["""RobertaPreLayerNormForMaskedLM"""]				)

							# convert state_dict
							snake_case_           =		torch.load(hf_hub_download(repo_id=_SCREAMING_SNAKE_CASE				, filename="""pytorch_model.bin"""				)				)
							snake_case_           =		{}
							for tensor_key, tensor_value in original_state_dict.items():
														# The transformer implementation gives the model a unique name, rather than overwiriting 'roberta'
														if tensor_key.startswith("""roberta."""				):
																					snake_case_           =		"""roberta_prelayernorm.""" + tensor_key[len("""roberta."""				) :]

														# The original implementation contains weights which are not used, remove them from the state_dict
														if tensor_key.endswith(""".self.LayerNorm.weight"""				) or tensor_key.endswith(""".self.LayerNorm.bias"""				):
																					continue

														snake_case_           =		tensor_value

							snake_case_           =		RobertaPreLayerNormForMaskedLM.from_pretrained(
							    pretrained_model_name_or_path=_SCREAMING_SNAKE_CASE				, config=_SCREAMING_SNAKE_CASE				, state_dict=_SCREAMING_SNAKE_CASE				)
							model.save_pretrained(_SCREAMING_SNAKE_CASE				)

							# convert tokenizer
							snake_case_           =		AutoTokenizer.from_pretrained(_SCREAMING_SNAKE_CASE				)
							tokenizer.save_pretrained(_SCREAMING_SNAKE_CASE				)


if __name__ == "__main__":
				__SCREAMING_SNAKE_CASE							:    Union[str, Any]		=    argparse.ArgumentParser()
				# Required parameters
				parser.add_argument(
				    '--checkpoint-repo',
				    default=None,
				    type=str,
				    required=True,
				    help='Path the official PyTorch dump, e.g. \'andreasmadsen/efficient_mlm_m0.40\'.',
				)
				parser.add_argument(
				    '--pytorch_dump_folder_path', default=None, type=str, required=True, help='Path to the output PyTorch model.'
				)
				__SCREAMING_SNAKE_CASE							:    List[Any]		=    parser.parse_args()
				convert_roberta_prelayernorm_checkpoint_to_pytorch(args.checkpoint_repo, args.pytorch_dump_folder_path)







"""simple docstring"""
from math import factorial







def 						_a				(      _SCREAMING_SNAKE_CASE = 100				)    ->				int:
							return sum(int(_SCREAMING_SNAKE_CASE				) for x in str(factorial(_SCREAMING_SNAKE_CASE				)				)				)


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



