





"""simple docstring"""





import argparse
import re

import numpy as np
import requests
import torch
from huggingface_hub import hf_hub_download
from PIL import Image

from transformers import (
    SamConfig,
    SamImageProcessor,
    SamModel,
    SamProcessor,
    SamVisionConfig,
)


SCREAMING_SNAKE_CASE__					=   {
    "iou_prediction_head.layers.0": "iou_prediction_head.proj_in",
    "iou_prediction_head.layers.1": "iou_prediction_head.layers.0",
    "iou_prediction_head.layers.2": "iou_prediction_head.proj_out",
    "mask_decoder.output_upscaling.0": "mask_decoder.upscale_conv1",
    "mask_decoder.output_upscaling.1": "mask_decoder.upscale_layer_norm",
    "mask_decoder.output_upscaling.3": "mask_decoder.upscale_conv2",
    "mask_downscaling.0": "mask_embed.conv1",
    "mask_downscaling.1": "mask_embed.layer_norm1",
    "mask_downscaling.3": "mask_embed.conv2",
    "mask_downscaling.4": "mask_embed.layer_norm2",
    "mask_downscaling.6": "mask_embed.conv3",
    "point_embeddings": "point_embed",
    "pe_layer.positional_encoding_gaussian_matrix": "shared_embedding.positional_embedding",
    "image_encoder": "vision_encoder",
    "neck.0": "neck.conv1",
    "neck.1": "neck.layer_norm1",
    "neck.2": "neck.conv2",
    "neck.3": "neck.layer_norm2",
    "patch_embed.proj": "patch_embed.projection",
    ".norm": ".layer_norm",
    "blocks": "layers",
}


def 			UpperCAmelCase__							(  SCREAMING_SNAKE_CASE     :						Any			):







      '''simple docstring'''




      lowerCAmelCase  						=       {}
      state_dict.pop("""pixel_mean"""							,						_A			)
      state_dict.pop("""pixel_std"""							,						_A			)

      lowerCAmelCase  						=       R""".*.output_hypernetworks_mlps.(\d+).layers.(\d+).*"""

      for key, value in state_dict.items():
            for key_to_modify, new_key in KEYS_TO_MODIFY_MAPPING.items():
                  if key_to_modify in key:
                        lowerCAmelCase  						=       key.replace(_A							,						_A			)

            if re.match(_A							,						_A			):
                  lowerCAmelCase  						=       int(re.match(_A							,						_A			).group(2			)			)
                  if layer_nb == 0:
                        lowerCAmelCase  						=       key.replace("""layers.0"""							,						"""proj_in"""			)
                  elif layer_nb == 1:
                        lowerCAmelCase  						=       key.replace("""layers.1"""							,						"""layers.0"""			)
                  elif layer_nb == 2:
                        lowerCAmelCase  						=       key.replace("""layers.2"""							,						"""proj_out"""			)

            lowerCAmelCase  						=       value

      lowerCAmelCase  						=       model_state_dict[
          """prompt_encoder.shared_embedding.positional_embedding"""
      ]

      return model_state_dict


def 			UpperCAmelCase__							(  SCREAMING_SNAKE_CASE     :						Tuple							,						SCREAMING_SNAKE_CASE     :						Tuple							,						SCREAMING_SNAKE_CASE     :						Any							,						SCREAMING_SNAKE_CASE     :						Tuple="ybelkada/segment-anything"			):







      '''simple docstring'''




      lowerCAmelCase  						=       hf_hub_download(_A							,						F'checkpoints/{model_name}.pth'			)

      if "sam_vit_b" in model_name:
            lowerCAmelCase  						=       SamConfig()
      elif "sam_vit_l" in model_name:
            lowerCAmelCase  						=       SamVisionConfig(
                hidden_size=10_24							,						num_hidden_layers=24							,						num_attention_heads=16							,						global_attn_indexes=[5, 11, 17, 23]							,						)

            lowerCAmelCase  						=       SamConfig(
                vision_config=_A							,						)
      elif "sam_vit_h" in model_name:
            lowerCAmelCase  						=       SamVisionConfig(
                hidden_size=12_80							,						num_hidden_layers=32							,						num_attention_heads=16							,						global_attn_indexes=[7, 15, 23, 31]							,						)

            lowerCAmelCase  						=       SamConfig(
                vision_config=_A							,						)

      lowerCAmelCase  						=       torch.load(_A							,						map_location="""cpu"""			)
      lowerCAmelCase  						=       replace_keys(_A			)

      lowerCAmelCase  						=       SamImageProcessor()

      lowerCAmelCase  						=       SamProcessor(image_processor=_A			)
      lowerCAmelCase  						=       SamModel(_A			)

      hf_model.load_state_dict(_A			)
      lowerCAmelCase  						=       hf_model.to("""cuda"""			)

      lowerCAmelCase  						=       """https://huggingface.co/ybelkada/segment-anything/resolve/main/assets/car.png"""
      lowerCAmelCase  						=       Image.open(requests.get(_A							,						stream=_A			).raw			).convert("""RGB"""			)

      lowerCAmelCase  						=       [[[4_00, 6_50]]]
      lowerCAmelCase  						=       [[1]]

      lowerCAmelCase  						=       processor(images=np.array(_A			)							,						return_tensors="""pt"""			).to("""cuda"""			)

      with torch.no_grad():
            lowerCAmelCase  						=       hf_model(**_A			)
      lowerCAmelCase  						=       output.iou_scores.squeeze()

      if model_name == "sam_vit_h_4b8939":
            assert scores[-1].item() == 0.5_79_89_02_51_15_96_68

            lowerCAmelCase  						=       processor(
                images=np.array(_A			)							,						input_points=_A							,						input_labels=_A							,						return_tensors="""pt"""			).to("""cuda"""			)

            with torch.no_grad():
                  lowerCAmelCase  						=       hf_model(**_A			)
            lowerCAmelCase  						=       output.iou_scores.squeeze()

            assert scores[-1].item() == 0.97_12_60_30_92_19_36_04

            lowerCAmelCase  						=       ((75, 2_75, 17_25, 8_50),)

            lowerCAmelCase  						=       processor(images=np.array(_A			)							,						input_boxes=_A							,						return_tensors="""pt"""			).to("""cuda"""			)

            with torch.no_grad():
                  lowerCAmelCase  						=       hf_model(**_A			)
            lowerCAmelCase  						=       output.iou_scores.squeeze()

            assert scores[-1].item() == 0.86_86_01_56_05_92_65_14

            # Test with 2 points and 1 image.
            lowerCAmelCase  						=       [[[4_00, 6_50], [8_00, 6_50]]]
            lowerCAmelCase  						=       [[1, 1]]

            lowerCAmelCase  						=       processor(
                images=np.array(_A			)							,						input_points=_A							,						input_labels=_A							,						return_tensors="""pt"""			).to("""cuda"""			)

            with torch.no_grad():
                  lowerCAmelCase  						=       hf_model(**_A			)
            lowerCAmelCase  						=       output.iou_scores.squeeze()

            assert scores[-1].item() == 0.99_36_04_77_92_43_46_92


if __name__ == "__main__":
       SCREAMING_SNAKE_CASE__					=   argparse.ArgumentParser()
       SCREAMING_SNAKE_CASE__					=   ["sam_vit_b_01ec64", "sam_vit_h_4b8939", "sam_vit_l_0b3195"]
       parser.add_argument(
           "--model_name",
           default="sam_vit_h_4b8939",
           choices=choices,
           type=str,
           help="Path to hf config.json of model to convert",
       )
       parser.add_argument("--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model.")
       parser.add_argument(
           "--push_to_hub",
           action="store_true",
           help="Whether to push the model and processor to the hub after converting",
       )
       parser.add_argument(
           "--model_hub_id",
           default="ybelkada/segment-anything",
           choices=choices,
           type=str,
           help="Path to hf config.json of model to convert",
       )

       SCREAMING_SNAKE_CASE__					=   parser.parse_args()

       convert_sam_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub, args.model_hub_id)









from math import factorial




def 			UpperCAmelCase__				(			_A      : int = 1_00							):





  '''simple docstring'''







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


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