

'''simple docstring'''

import argparse

import requests
import torch
from PIL import Image

from transformers import ViTMAEConfig, ViTMAEForPreTraining, ViTMAEImageProcessor




def 							_UpperCamelCase				(   lowerCAmelCase__:					Optional[Any]   )      -> List[Any]:
							if "cls_token" in name:
														SCREAMING_SNAKE_CASE_				=				name.replace('cls_token'		,'vit.embeddings.cls_token'   )
							if "mask_token" in name:
														SCREAMING_SNAKE_CASE_				=				name.replace('mask_token'		,'decoder.mask_token'   )
							if "decoder_pos_embed" in name:
														SCREAMING_SNAKE_CASE_				=				name.replace('decoder_pos_embed'		,'decoder.decoder_pos_embed'   )
							if "pos_embed" in name and "decoder" not in name:
														SCREAMING_SNAKE_CASE_				=				name.replace('pos_embed'		,'vit.embeddings.position_embeddings'   )
							if "patch_embed.proj" in name:
														SCREAMING_SNAKE_CASE_				=				name.replace('patch_embed.proj'		,'vit.embeddings.patch_embeddings.projection'   )
							if "patch_embed.norm" in name:
														SCREAMING_SNAKE_CASE_				=				name.replace('patch_embed.norm'		,'vit.embeddings.norm'   )
							if "decoder_blocks" in name:
														SCREAMING_SNAKE_CASE_				=				name.replace('decoder_blocks'		,'decoder.decoder_layers'   )
							if "blocks" in name:
														SCREAMING_SNAKE_CASE_				=				name.replace('blocks'		,'vit.encoder.layer'   )
							if "attn.proj" in name:
														SCREAMING_SNAKE_CASE_				=				name.replace('attn.proj'		,'attention.output.dense'   )
							if "attn" in name:
														SCREAMING_SNAKE_CASE_				=				name.replace('attn'		,'attention.self'   )
							if "norm1" in name:
														SCREAMING_SNAKE_CASE_				=				name.replace('norm1'		,'layernorm_before'   )
							if "norm2" in name:
														SCREAMING_SNAKE_CASE_				=				name.replace('norm2'		,'layernorm_after'   )
							if "mlp.fc1" in name:
														SCREAMING_SNAKE_CASE_				=				name.replace('mlp.fc1'		,'intermediate.dense'   )
							if "mlp.fc2" in name:
														SCREAMING_SNAKE_CASE_				=				name.replace('mlp.fc2'		,'output.dense'   )
							if "decoder_embed" in name:
														SCREAMING_SNAKE_CASE_				=				name.replace('decoder_embed'		,'decoder.decoder_embed'   )
							if "decoder_norm" in name:
														SCREAMING_SNAKE_CASE_				=				name.replace('decoder_norm'		,'decoder.decoder_norm'   )
							if "decoder_pred" in name:
														SCREAMING_SNAKE_CASE_				=				name.replace('decoder_pred'		,'decoder.decoder_pred'   )
							if "norm.weight" in name and "decoder" not in name:
														SCREAMING_SNAKE_CASE_				=				name.replace('norm.weight'		,'vit.layernorm.weight'   )
							if "norm.bias" in name and "decoder" not in name:
														SCREAMING_SNAKE_CASE_				=				name.replace('norm.bias'		,'vit.layernorm.bias'   )

							return name




def 							_UpperCamelCase				(   lowerCAmelCase__:					List[str]		,lowerCAmelCase__:					List[str]   )      -> Dict:
							for key in orig_state_dict.copy().keys():
														SCREAMING_SNAKE_CASE_				=				orig_state_dict.pop(lowerCAmelCase__   )

														if "qkv" in key:
																					SCREAMING_SNAKE_CASE_				=				key.split('.'   )
																					SCREAMING_SNAKE_CASE_				=				int(key_split[1]   )
																					if "decoder_blocks" in key:
																												SCREAMING_SNAKE_CASE_				=				config.decoder_hidden_size
																												SCREAMING_SNAKE_CASE_				=				'decoder.decoder_layers.'
																												if "weight" in key:
																																			SCREAMING_SNAKE_CASE_				=				val[:dim, :]
																																			SCREAMING_SNAKE_CASE_				=				val[dim : dim * 2, :]
																																			SCREAMING_SNAKE_CASE_				=				val[-dim:, :]
																												elif "bias" in key:
																																			SCREAMING_SNAKE_CASE_				=				val[:dim]
																																			SCREAMING_SNAKE_CASE_				=				val[dim : dim * 2]
																																			SCREAMING_SNAKE_CASE_				=				val[-dim:]
																					else:
																												SCREAMING_SNAKE_CASE_				=				config.hidden_size
																												SCREAMING_SNAKE_CASE_				=				'vit.encoder.layer.'
																												if "weight" in key:
																																			SCREAMING_SNAKE_CASE_				=				val[:dim, :]
																																			SCREAMING_SNAKE_CASE_				=				val[dim : dim * 2, :]
																																			SCREAMING_SNAKE_CASE_				=				val[-dim:, :]
																												elif "bias" in key:
																																			SCREAMING_SNAKE_CASE_				=				val[:dim]
																																			SCREAMING_SNAKE_CASE_				=				val[dim : dim * 2]
																																			SCREAMING_SNAKE_CASE_				=				val[-dim:]

														else:
																					SCREAMING_SNAKE_CASE_				=				val

							return orig_state_dict




def 							_UpperCamelCase				(   lowerCAmelCase__:					Union[str, Any]		,lowerCAmelCase__:					str   )      -> Tuple:
							SCREAMING_SNAKE_CASE_				=				ViTMAEConfig()
							if "large" in checkpoint_url:
														SCREAMING_SNAKE_CASE_				=				1024
														SCREAMING_SNAKE_CASE_				=				4096
														SCREAMING_SNAKE_CASE_				=				24
														SCREAMING_SNAKE_CASE_				=				16
							elif "huge" in checkpoint_url:
														SCREAMING_SNAKE_CASE_				=				14
														SCREAMING_SNAKE_CASE_				=				1280
														SCREAMING_SNAKE_CASE_				=				5120
														SCREAMING_SNAKE_CASE_				=				32
														SCREAMING_SNAKE_CASE_				=				16

							SCREAMING_SNAKE_CASE_				=				ViTMAEForPreTraining(lowerCAmelCase__   )

							SCREAMING_SNAKE_CASE_				=				torch.hub.load_state_dict_from_url(lowerCAmelCase__		,map_location='cpu'   )['model']

							SCREAMING_SNAKE_CASE_				=				ViTMAEImageProcessor(size=config.image_size   )

							SCREAMING_SNAKE_CASE_				=				convert_state_dict(lowerCAmelCase__		,lowerCAmelCase__   )

							model.load_state_dict(lowerCAmelCase__   )
							model.eval()

							SCREAMING_SNAKE_CASE_				=				'https://user-images.githubusercontent.com/11435359/147738734-196fd92f-9260-48d5-ba7e-bf103d29364d.jpg'

							SCREAMING_SNAKE_CASE_				=				Image.open(requests.get(lowerCAmelCase__		,stream=lowerCAmelCase__   ).raw   )
							SCREAMING_SNAKE_CASE_				=				ViTMAEImageProcessor(size=config.image_size   )
							SCREAMING_SNAKE_CASE_				=				image_processor(images=lowerCAmelCase__		,return_tensors='pt'   )

							# forward pass
							torch.manual_seed(2   )
							SCREAMING_SNAKE_CASE_				=				model(**lowerCAmelCase__   )
							SCREAMING_SNAKE_CASE_				=				outputs.logits

							if "large" in checkpoint_url:
														SCREAMING_SNAKE_CASE_				=				torch.tensor(
														    [[-0.7_309, -0.7_128, -1.0_169], [-1.0_161, -0.9_058, -1.1_878], [-1.0_478, -0.9_411, -1.1_911]]   )
							elif "huge" in checkpoint_url:
														SCREAMING_SNAKE_CASE_				=				torch.tensor(
														    [[-1.1_599, -0.9_199, -1.2_221], [-1.1_952, -0.9_269, -1.2_307], [-1.2_143, -0.9_337, -1.2_262]]   )
							else:
														SCREAMING_SNAKE_CASE_				=				torch.tensor(
														    [[-0.9_192, -0.8_481, -1.1_259], [-1.1_349, -1.0_034, -1.2_599], [-1.1_757, -1.0_429, -1.2_726]]   )

							# verify logits
							assert torch.allclose(logits[0, :3, :3]		,lowerCAmelCase__		,atol=1E-4   )

							print(F"""Saving model to {pytorch_dump_folder_path}"""   )
							model.save_pretrained(lowerCAmelCase__   )

							print(F"""Saving image processor to {pytorch_dump_folder_path}"""   )
							image_processor.save_pretrained(lowerCAmelCase__   )


if __name__ == "__main__":
							SCREAMING_SNAKE_CASE							:				Optional[Any]     	=			argparse.ArgumentParser()
							# Required parameters
							parser.add_argument(
							    "--checkpoint_url",
							    default="https://dl.fbaipublicfiles.com/mae/visualize/mae_visualize_vit_base.pth",
							    type=str,
							    help="URL of the checkpoint you'd like to convert.",
							)
							parser.add_argument(
							    "--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model directory."
							)

							SCREAMING_SNAKE_CASE							:				str     	=			parser.parse_args()
							convert_vit_mae_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path)








'''simple docstring'''

from math import factorial




def 							_UpperCamelCase				(   lowerCAmelCase__:					int = 100   )      -> int:
							return sum(map(lowerCAmelCase__		,str(factorial(lowerCAmelCase__   )   )   )   )


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





