
from __future__ import annotations

import math




def  lowerCamelCase__ (  a__     :     str   )						->		List[Any]:

       if 1 < number < 4:
              # 2 and 3 are primes
              return True
       elif number < 2 or number % 2 == 0 or number % 3 == 0:
              # Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
              return False

       # All primes number are in format of 6k +/- 1
       for i in range(5		,					int(math.sqrt(__lowerCAmelCase   ) + 1   )		,					6   ):
              if number % i == 0 or number % (i + 2) == 0:
                     return False
       return True




def  lowerCamelCase__ (  a__     :     str   )						->		str:
       UpperCamelCase_											=				str(__lowerCAmelCase   )
       UpperCamelCase_											=				[n]
       for i in range(1		,					len(__lowerCAmelCase   )   ):
              list_nums.append(int(str_num[i:]   )   )
              list_nums.append(int(str_num[:-i]   )   )
       return list_nums




def  lowerCamelCase__ (  a__     :     List[str]   )						->		Tuple:
       if len(str(__lowerCAmelCase   )   ) > 3:
              if not is_prime(int(str(__lowerCAmelCase   )[-3:]   )   ) or not is_prime(int(str(__lowerCAmelCase   )[:3]   )   ):
                     return False
       return True




def  lowerCamelCase__ (  a__     :     Optional[Any] = 11   )						->		Any:
       UpperCamelCase_											=				[]
       UpperCamelCase_											=				13
       while len(__lowerCAmelCase   ) != count:
              if validate(__lowerCAmelCase   ):
                     UpperCamelCase_											=				list_truncated_nums(__lowerCAmelCase   )
                     if all(is_prime(__lowerCAmelCase   ) for i in list_nums   ):
                            list_truncated_primes.append(__lowerCAmelCase   )
              num += 2
       return list_truncated_primes




def  lowerCamelCase__ (  )						->		Dict:
       return sum(compute_truncated_primes(11   )   )


if __name__ == "__main__":
      print(F'''{sum(compute_truncated_primes(11)) = }''')







'''simple docstring'''


import argparse
import re
from pathlib import Path

import requests
import torch
from PIL import Image
from torchvision.transforms import CenterCrop, Compose, Normalize, Resize, ToTensor

from transformers import (
    EfficientFormerConfig,
    EfficientFormerForImageClassificationWithTeacher,
    EfficientFormerImageProcessor,
)
from transformers.image_utils import IMAGENET_DEFAULT_MEAN, IMAGENET_DEFAULT_STD, PILImageResampling






def        __lowerCAmelCase       (__lowerCAmelCase					,       __lowerCAmelCase      ):
		_UpperCAmelCase						:				Union[str, Any]	    =					old_name

		if "patch_embed" in old_name:
				_UpperCAmelCase    ,			_UpperCAmelCase    ,			_UpperCAmelCase						:				Dict	    =					old_name.split("."      )

				if layer == "0":
						_UpperCAmelCase						:				List[str]	    =					old_name.replace("0"					,       "convolution1"      )
				elif layer == "1":
						_UpperCAmelCase						:				Dict	    =					old_name.replace("1"					,       "batchnorm_before"      )
				elif layer == "3":
						_UpperCAmelCase						:				Tuple	    =					old_name.replace("3"					,       "convolution2"      )
				else:
						_UpperCAmelCase						:				Tuple	    =					old_name.replace("4"					,       "batchnorm_after"      )

		if "network" in old_name and re.search(R"\d\.\d"					,       __lowerCAmelCase      ):
				_UpperCAmelCase						:				List[Any]	    =					R"\b\d{2}\b"
				if bool(re.search(__lowerCAmelCase					,       __lowerCAmelCase      )      ):
						_UpperCAmelCase						:				Optional[int]	    =					re.search(R"\d\.\d\d."					,       __lowerCAmelCase      ).group()
				else:
						_UpperCAmelCase						:				Any	    =					re.search(R"\d\.\d."					,       __lowerCAmelCase      ).group()
				if int(match[0]      ) < 6:
						_UpperCAmelCase						:				str	    =					old_name.replace(__lowerCAmelCase					,       ""      )
						_UpperCAmelCase						:				Optional[Any]	    =					trimmed_name.replace("network"					,       match[0] + ".meta4D_layers.blocks." + match[2:-1]      )
						_UpperCAmelCase						:				Union[str, Any]	    =					"intermediate_stages." + trimmed_name
				else:
						_UpperCAmelCase						:				Tuple	    =					old_name.replace(__lowerCAmelCase					,       ""      )
						if int(match[2]      ) < num_meta4D_last_stage:
								_UpperCAmelCase						:				Any	    =					trimmed_name.replace("network"					,       "meta4D_layers.blocks." + match[2]      )
						else:
								_UpperCAmelCase						:				List[str]	    =					str(int(match[2]      ) - num_meta4D_last_stage      )
								_UpperCAmelCase						:				int	    =					trimmed_name.replace("network"					,       "meta3D_layers.blocks." + layer_index      )
								if "norm1" in old_name:
										_UpperCAmelCase						:				Tuple	    =					trimmed_name.replace("norm1"					,       "layernorm1"      )
								elif "norm2" in old_name:
										_UpperCAmelCase						:				int	    =					trimmed_name.replace("norm2"					,       "layernorm2"      )
								elif "fc1" in old_name:
										_UpperCAmelCase						:				Optional[int]	    =					trimmed_name.replace("fc1"					,       "linear_in"      )
								elif "fc2" in old_name:
										_UpperCAmelCase						:				List[str]	    =					trimmed_name.replace("fc2"					,       "linear_out"      )

						_UpperCAmelCase						:				Optional[Any]	    =					"last_stage." + trimmed_name

		elif "network" in old_name and re.search(R".\d."					,       __lowerCAmelCase      ):
				_UpperCAmelCase						:				Optional[Any]	    =					old_name.replace("network"					,       "intermediate_stages"      )

		if "fc" in new_name:
				_UpperCAmelCase						:				Union[str, Any]	    =					new_name.replace("fc"					,       "convolution"      )
		elif ("norm1" in new_name) and ("layernorm1" not in new_name):
				_UpperCAmelCase						:				List[Any]	    =					new_name.replace("norm1"					,       "batchnorm_before"      )
		elif ("norm2" in new_name) and ("layernorm2" not in new_name):
				_UpperCAmelCase						:				List[Any]	    =					new_name.replace("norm2"					,       "batchnorm_after"      )
		if "proj" in new_name:
				_UpperCAmelCase						:				Union[str, Any]	    =					new_name.replace("proj"					,       "projection"      )
		if "dist_head" in new_name:
				_UpperCAmelCase						:				List[Any]	    =					new_name.replace("dist_head"					,       "distillation_classifier"      )
		elif "head" in new_name:
				_UpperCAmelCase						:				str	    =					new_name.replace("head"					,       "classifier"      )
		elif "patch_embed" in new_name:
				_UpperCAmelCase						:				List[str]	    =					"efficientformer." + new_name
		elif new_name == "norm.weight" or new_name == "norm.bias":
				_UpperCAmelCase						:				List[Any]	    =					new_name.replace("norm"					,       "layernorm"      )
				_UpperCAmelCase						:				Any	    =					"efficientformer." + new_name
		else:
				_UpperCAmelCase						:				Dict	    =					"efficientformer.encoder." + new_name

		return new_name






def        __lowerCAmelCase       (__lowerCAmelCase					,       __lowerCAmelCase      ):
		for key in checkpoint.copy().keys():
				_UpperCAmelCase						:				List[Any]	    =					checkpoint.pop(__lowerCAmelCase      )
				_UpperCAmelCase						:				List[Any]	    =					val

		return checkpoint






def        __lowerCAmelCase       ():
		_UpperCAmelCase						:				Optional[int]	    =					"http://images.cocodataset.org/val2017/000000039769.jpg"
		_UpperCAmelCase						:				Tuple	    =					Image.open(requests.get(__lowerCAmelCase					,       stream=__lowerCAmelCase      ).raw      )

		return image






def        __lowerCAmelCase       (__lowerCAmelCase					,       __lowerCAmelCase					,       __lowerCAmelCase					,       __lowerCAmelCase      ):
		_UpperCAmelCase						:				Union[str, Any]	    =					torch.load(__lowerCAmelCase					,       map_location="cpu"      )["model"]
		_UpperCAmelCase						:				Dict	    =					EfficientFormerConfig.from_json_file(__lowerCAmelCase      )
		_UpperCAmelCase						:				Optional[Any]	    =					EfficientFormerForImageClassificationWithTeacher(__lowerCAmelCase      )
		_UpperCAmelCase						:				Tuple	    =					"_".join(checkpoint_path.split("/"      )[-1].split("."      )[0].split("_"      )[:-1]      )

		_UpperCAmelCase						:				Union[str, Any]	    =					config.depths[-1] - config.num_metaad_blocks + 1
		_UpperCAmelCase						:				Optional[int]	    =					convert_torch_checkpoint(__lowerCAmelCase					,       __lowerCAmelCase      )

		model.load_state_dict(__lowerCAmelCase      )
		model.eval()

		_UpperCAmelCase						:				Optional[Any]	    =					{
		    "bilinear": PILImageResampling.BILINEAR,
		    "bicubic": PILImageResampling.BICUBIC,
		    "nearest": PILImageResampling.NEAREST,
		}

		# prepare image
		_UpperCAmelCase						:				int	    =					prepare_img()
		_UpperCAmelCase						:				List[str]	    =					256
		_UpperCAmelCase						:				Optional[int]	    =					224
		_UpperCAmelCase						:				Tuple	    =					EfficientFormerImageProcessor(
		    size={"shortest_edge": image_size}					,       crop_size={"height": crop_size, "width": crop_size}					,       resample=pillow_resamplings["bicubic"]					,       )
		_UpperCAmelCase						:				Any	    =					processor(images=__lowerCAmelCase					,       return_tensors="pt"      ).pixel_values

		# original processing pipeline
		_UpperCAmelCase						:				int	    =					Compose(
		    [
		        Resize(__lowerCAmelCase					,       interpolation=pillow_resamplings["bicubic"]      ),
		        CenterCrop(__lowerCAmelCase      ),
		        ToTensor(),
		        Normalize(__lowerCAmelCase					,       __lowerCAmelCase      ),
		    ]      )
		_UpperCAmelCase						:				Any	    =					image_transforms(__lowerCAmelCase      ).unsqueeze(0      )

		assert torch.allclose(__lowerCAmelCase					,       __lowerCAmelCase      )

		_UpperCAmelCase						:				Union[str, Any]	    =					model(__lowerCAmelCase      )
		_UpperCAmelCase						:				Dict	    =					outputs.logits

		_UpperCAmelCase						:				Optional[int]	    =					(1, 1_000)

		if "l1" in model_name:
				_UpperCAmelCase						:				List[Any]	    =					torch.Tensor(
				    [-0.1_3_1_2, 0.4_3_5_3, -1.0_4_9_9, -0.5_1_2_4, 0.4_1_8_3, -0.6_7_9_3, -1.3_7_7_7, -0.0_8_9_3, -0.7_3_5_8, -2.4_3_2_8]      )
				assert torch.allclose(logits[0, :10]					,       __lowerCAmelCase					,       atol=1e-3      )
				assert logits.shape == expected_shape
		elif "l3" in model_name:
				_UpperCAmelCase						:				List[Any]	    =					torch.Tensor(
				    [-1.3_1_5_0, -1.5_4_5_6, -1.2_5_5_6, -0.8_4_9_6, -0.7_1_2_7, -0.7_8_9_7, -0.9_7_2_8, -0.3_0_5_2, 0.3_7_5_1, -0.3_1_2_7]      )
				assert torch.allclose(logits[0, :10]					,       __lowerCAmelCase					,       atol=1e-3      )
				assert logits.shape == expected_shape
		elif "l7" in model_name:
				_UpperCAmelCase						:				List[Any]	    =					torch.Tensor(
				    [-1.0_2_8_3, -1.4_1_3_1, -0.5_6_4_4, -1.3_1_1_5, -0.5_7_8_5, -1.2_0_4_9, -0.7_5_2_8, 0.1_9_9_2, -0.3_8_2_2, -0.0_8_7_8]      )
				assert logits.shape == expected_shape
		else:
				raise ValueError(
				    F"""Unknown model checkpoint: {checkpoint_path}. Supported version of efficientformer are l1, l3 and l7"""      )

		# Save Checkpoints
		Path(__lowerCAmelCase      ).mkdir(exist_ok=__lowerCAmelCase      )
		model.save_pretrained(__lowerCAmelCase      )
		print(F"""Checkpoint successfuly converted. Model saved at {pytorch_dump_path}"""      )
		processor.save_pretrained(__lowerCAmelCase      )
		print(F"""Processor successfuly saved at {pytorch_dump_path}"""      )

		if push_to_hub:
				print("Pushing model to the hub..."      )

				model.push_to_hub(
				    repo_id=F"""Bearnardd/{pytorch_dump_path}"""					,       commit_message="Add model"					,       use_temp_dir=__lowerCAmelCase					,       )
				processor.push_to_hub(
				    repo_id=F"""Bearnardd/{pytorch_dump_path}"""					,       commit_message="Add image processor"					,       use_temp_dir=__lowerCAmelCase					,       )


if __name__ == "__main__":
						lowerCamelCase__					=   argparse.ArgumentParser()
						# Required parameters
						parser.add_argument(
						    '--pytorch_model_path',
						    default=None,
						    type=str,
						    required=True,
						    help='Path to EfficientFormer pytorch checkpoint.',
						)
						parser.add_argument(
						    '--config_file',
						    default=None,
						    type=str,
						    required=True,
						    help='The json file for EfficientFormer model config.',
						)
						parser.add_argument(
						    '--pytorch_dump_path', default=None, type=str, required=True, help='Path to the output PyTorch model.'
						)

						parser.add_argument('--push_to_hub', action='store_true', help='Push model and image processor to the hub')
						parser.add_argument(
						    '--no-push_to_hub',
						    dest='push_to_hub',
						    action='store_false',
						    help='Do not push model and image processor to the hub',
						)
						parser.set_defaults(push_to_hub=True)

						lowerCamelCase__					=   parser.parse_args()
						convert_efficientformer_checkpoint(
						    checkpoint_path=args.pytorch_model_path,
						    efficientformer_config_file=args.config_file,
						    pytorch_dump_path=args.pytorch_dump_path,
						    push_to_hub=args.push_to_hub,
						)



