





import argparse

import requests
import torch
from PIL import Image

from transformers import ViTMAEConfig, ViTMAEForPreTraining, ViTMAEImageProcessor



def _a				(	lowerCamelCase:   Union[str, Any] )	->						Tuple:







      '''simple docstring'''






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

      return name



def _a				(	lowerCamelCase:   Dict					,				lowerCamelCase:   Optional[int] )	->						Optional[Any]:







      '''simple docstring'''






      for key in orig_state_dict.copy().keys():
            __A          =				orig_state_dict.pop(lowerCamelCase )

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

            else:
                  __A          =				val

      return orig_state_dict



def _a				(	lowerCamelCase:   List[Any]					,				lowerCamelCase:   Optional[int] )	->						Any:







      '''simple docstring'''






      __A          =				ViTMAEConfig()
      if "large" in checkpoint_url:
            __A          =				10_24
            __A          =				40_96
            __A          =				24
            __A          =				16
      elif "huge" in checkpoint_url:
            __A          =				14
            __A          =				12_80
            __A          =				51_20
            __A          =				32
            __A          =				16

      __A          =				ViTMAEForPreTraining(lowerCamelCase )

      __A          =				torch.hub.load_state_dict_from_url(lowerCamelCase					,				map_location='''cpu''' )['''model''']

      __A          =				ViTMAEImageProcessor(size=config.image_size )

      __A          =				convert_state_dict(lowerCamelCase					,				lowerCamelCase )

      model.load_state_dict(lowerCamelCase )
      model.eval()

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

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

      # forward pass
      torch.manual_seed(2 )
      __A          =				model(**lowerCamelCase )
      __A          =				outputs.logits

      if "large" in checkpoint_url:
            __A          =				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:
            __A          =				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:
            __A          =				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__":
       snake_case__					:							Union[str, 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.'
       )

       snake_case__					:							Dict													=     parser.parse_args()
       convert_vit_mae_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path)












from itertools import permutations



def _a				(	lowerCamelCase:   tuple )	->						bool:







      '''simple docstring'''






      if num[3] % 2 != 0:
            return False

      if (num[2] + num[3] + num[4]) % 3 != 0:
            return False

      if num[5] % 5 != 0:
            return False

      __A          =				[7, 11, 13, 17]
      for i, test in enumerate(lowerCamelCase ):
            if (num[i + 4] * 1_00 + num[i + 5] * 10 + num[i + 6]) % test != 0:
                  return False
      return True



def _a				(	lowerCamelCase:   int = 10 )	->						int:







      '''simple docstring'''






      return sum(
          int(''''''.join(map(lowerCamelCase					,				lowerCamelCase ) ) )
          for num in permutations(range(lowerCamelCase ) )
          if is_substring_divisible(lowerCamelCase ) )


if __name__ == "__main__":
       print(f'{solution() = }')





