

import argparse
import json
import os

import requests
import torch
from huggingface_hub import hf_hub_download
from PIL import Image

from transformers import ConvNextImageProcessor, ConvNextVaConfig, ConvNextVaForImageClassification
from transformers.image_utils import PILImageResampling
from transformers.utils import logging


logging.set_verbosity_info()
_SCREAMING_SNAKE_CASE          = logging.get_logger(__name__)





def    _snake_case		(snake_case_				:    List[str]     )       ->		int:
		__UpperCAmelCase  :     str		=    ConvNextVaConfig()

		if "atto" in checkpoint_url:
				__UpperCAmelCase  :     Tuple		=    [2, 2, 6, 2]
				__UpperCAmelCase  :     Optional[Any]		=    [40, 80, 160, 320]
		if "femto" in checkpoint_url:
				__UpperCAmelCase  :     Optional[int]		=    [2, 2, 6, 2]
				__UpperCAmelCase  :     List[Any]		=    [48, 96, 192, 384]
		if "pico" in checkpoint_url:
				__UpperCAmelCase  :     Tuple		=    [2, 2, 6, 2]
				__UpperCAmelCase  :     List[str]		=    [64, 128, 256, 512]
		if "nano" in checkpoint_url:
				__UpperCAmelCase  :     str		=    [2, 2, 8, 2]
				__UpperCAmelCase  :     Optional[int]		=    [80, 160, 320, 640]
		if "tiny" in checkpoint_url:
				__UpperCAmelCase  :     Union[str, Any]		=    [3, 3, 9, 3]
				__UpperCAmelCase  :     str		=    [96, 192, 384, 768]
		if "base" in checkpoint_url:
				__UpperCAmelCase  :     int		=    [3, 3, 27, 3]
				__UpperCAmelCase  :     Tuple		=    [128, 256, 512, 1024]
		if "large" in checkpoint_url:
				__UpperCAmelCase  :     str		=    [3, 3, 27, 3]
				__UpperCAmelCase  :     Dict		=    [192, 384, 768, 1536]
		if "huge" in checkpoint_url:
				__UpperCAmelCase  :     Tuple		=    [3, 3, 27, 3]
				__UpperCAmelCase  :     Optional[Any]		=    [352, 704, 1408, 2816]

		__UpperCAmelCase  :     str		=    1000
		__UpperCAmelCase  :     Any		=    'imagenet-1k-id2label.json'
		__UpperCAmelCase  :     str		=    (1, 1000)

		__UpperCAmelCase  :     List[str]		=    'huggingface/label-files'
		__UpperCAmelCase  :     List[str]		=    num_labels
		__UpperCAmelCase  :     str		=    json.load(open(hf_hub_download(snake_case_						,					snake_case_						,					repo_type='dataset'     )						,					'r'     )     )
		__UpperCAmelCase  :     Optional[int]		=    {int(snake_case_     ): v for k, v in idalabel.items()}

		__UpperCAmelCase  :     Optional[int]		=    idalabel
		__UpperCAmelCase  :     List[Any]		=    {v: k for k, v in idalabel.items()}
		__UpperCAmelCase  :     Tuple		=    hidden_sizes
		__UpperCAmelCase  :     List[str]		=    depths

		return config, expected_shape





def    _snake_case		(snake_case_				:    Any     )       ->		Union[str, Any]:
		if "downsample_layers.0.0" in name:
				__UpperCAmelCase  :     List[str]		=    name.replace('downsample_layers.0.0'						,					'embeddings.patch_embeddings'     )
		if "downsample_layers.0.1" in name:
				__UpperCAmelCase  :     str		=    name.replace('downsample_layers.0.1'						,					'embeddings.norm'     )  # we rename to layernorm later on
		if "downsample_layers.1.0" in name:
				__UpperCAmelCase  :     Optional[Any]		=    name.replace('downsample_layers.1.0'						,					'stages.1.downsampling_layer.0'     )
		if "downsample_layers.1.1" in name:
				__UpperCAmelCase  :     int		=    name.replace('downsample_layers.1.1'						,					'stages.1.downsampling_layer.1'     )
		if "downsample_layers.2.0" in name:
				__UpperCAmelCase  :     str		=    name.replace('downsample_layers.2.0'						,					'stages.2.downsampling_layer.0'     )
		if "downsample_layers.2.1" in name:
				__UpperCAmelCase  :     Any		=    name.replace('downsample_layers.2.1'						,					'stages.2.downsampling_layer.1'     )
		if "downsample_layers.3.0" in name:
				__UpperCAmelCase  :     int		=    name.replace('downsample_layers.3.0'						,					'stages.3.downsampling_layer.0'     )
		if "downsample_layers.3.1" in name:
				__UpperCAmelCase  :     List[Any]		=    name.replace('downsample_layers.3.1'						,					'stages.3.downsampling_layer.1'     )
		if "stages" in name and "downsampling_layer" not in name:
				# stages.0.0. for instance should be renamed to stages.0.layers.0.
				__UpperCAmelCase  :     Optional[int]		=    name[: len('stages.0'     )] + '.layers' + name[len('stages.0'     ) :]
		if "gamma" in name:
				__UpperCAmelCase  :     Tuple		=    name.replace('gamma'						,					'weight'     )
		if "beta" in name:
				__UpperCAmelCase  :     List[Any]		=    name.replace('beta'						,					'bias'     )
		if "stages" in name:
				__UpperCAmelCase  :     str		=    name.replace('stages'						,					'encoder.stages'     )
		if "norm" in name:
				__UpperCAmelCase  :     List[Any]		=    name.replace('norm'						,					'layernorm'     )
		if "head" in name:
				__UpperCAmelCase  :     List[str]		=    name.replace('head'						,					'classifier'     )

		return name





def    _snake_case		()       ->		str:
		__UpperCAmelCase  :     Dict		=    'http://images.cocodataset.org/val2017/000000039769.jpg'
		__UpperCAmelCase  :     str		=    Image.open(requests.get(snake_case_						,					stream=snake_case_     ).raw     )
		return im





def    _snake_case		(snake_case_				:    Dict     )       ->		int:
		if "224" in checkpoint_url:
				__UpperCAmelCase  :     Union[str, Any]		=    224
				__UpperCAmelCase  :     int		=    224 / 256
		elif "384" in checkpoint_url:
				__UpperCAmelCase  :     int		=    384
				__UpperCAmelCase  :     List[str]		=    None
		else:
				__UpperCAmelCase  :     int		=    512
				__UpperCAmelCase  :     Optional[int]		=    None

		return ConvNextImageProcessor(
		    size=snake_case_						,					crop_pct=snake_case_						,					image_mean=[0.485, 0.456, 0.406]						,					image_std=[0.229, 0.224, 0.225]						,					resample=PILImageResampling.BICUBIC						,					)





@torch.no_grad()
def    _snake_case		(snake_case_				:    Optional[int]						,					snake_case_				:    int						,					snake_case_				:    List[Any]						,					snake_case_				:    Optional[Any]     )       ->		Union[str, Any]:
		print('Downloading original model from checkpoint...'     )
		# define ConvNeXTV2 configuration based on URL
		__UpperCAmelCase  :     List[Any]		=    get_convnextva_config(snake_case_     )
		# load original state_dict from URL
		__UpperCAmelCase  :     Optional[int]		=    torch.hub.load_state_dict_from_url(snake_case_     )['model']

		print('Converting model parameters...'     )
		# rename keys
		for key in state_dict.copy().keys():
				__UpperCAmelCase  :     List[Any]		=    state_dict.pop(snake_case_     )
				__UpperCAmelCase  :     Union[str, Any]		=    val
		# add prefix to all keys expect classifier head
		for key in state_dict.copy().keys():
				__UpperCAmelCase  :     List[Any]		=    state_dict.pop(snake_case_     )
				if not key.startswith('classifier'     ):
						__UpperCAmelCase  :     Dict		=    'convnextv2.' + key
				__UpperCAmelCase  :     Tuple		=    val

		# load HuggingFace model
		__UpperCAmelCase  :     str		=    ConvNextVaForImageClassification(snake_case_     )
		model.load_state_dict(snake_case_     )
		model.eval()

		# Check outputs on an image, prepared by ConvNextImageProcessor
		__UpperCAmelCase  :     List[str]		=    convert_preprocessor(snake_case_     )
		__UpperCAmelCase  :     Tuple		=    preprocessor(images=prepare_img()						,					return_tensors='pt'     )
		__UpperCAmelCase  :     Optional[int]		=    model(**snake_case_     ).logits

		# note: the logits below were obtained without center cropping
		if checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im1k/convnextv2_atto_1k_224_ema.pt":
				__UpperCAmelCase  :     Optional[int]		=    torch.tensor([-0.3930, 0.1747, -0.5246, 0.4177, 0.4295]     )
		elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im1k/convnextv2_femto_1k_224_ema.pt":
				__UpperCAmelCase  :     List[str]		=    torch.tensor([-0.1727, -0.5341, -0.7818, -0.4745, -0.6566]     )
		elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im1k/convnextv2_pico_1k_224_ema.pt":
				__UpperCAmelCase  :     List[Any]		=    torch.tensor([-0.0333, 0.1563, -0.9137, 0.1054, 0.0381]     )
		elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im1k/convnextv2_nano_1k_224_ema.pt":
				__UpperCAmelCase  :     Dict		=    torch.tensor([-0.1744, -0.1555, -0.0713, 0.0950, -0.1431]     )
		elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im1k/convnextv2_tiny_1k_224_ema.pt":
				__UpperCAmelCase  :     Optional[Any]		=    torch.tensor([0.9996, 0.1966, -0.4386, -0.3472, 0.6661]     )
		elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im1k/convnextv2_base_1k_224_ema.pt":
				__UpperCAmelCase  :     Optional[int]		=    torch.tensor([-0.2553, -0.6708, -0.1359, 0.2518, -0.2488]     )
		elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im1k/convnextv2_large_1k_224_ema.pt":
				__UpperCAmelCase  :     Optional[int]		=    torch.tensor([-0.0673, -0.5627, -0.3753, -0.2722, 0.0178]     )
		elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im1k/convnextv2_huge_1k_224_ema.pt":
				__UpperCAmelCase  :     Any		=    torch.tensor([-0.6377, -0.7458, -0.2150, 0.1184, -0.0597]     )
		elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im22k/convnextv2_nano_22k_224_ema.pt":
				__UpperCAmelCase  :     Dict		=    torch.tensor([1.0799, 0.2322, -0.8860, 1.0219, 0.6231]     )
		elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im22k/convnextv2_nano_22k_384_ema.pt":
				__UpperCAmelCase  :     str		=    torch.tensor([0.3766, 0.4917, -1.1426, 0.9942, 0.6024]     )
		elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im22k/convnextv2_tiny_22k_224_ema.pt":
				__UpperCAmelCase  :     str		=    torch.tensor([0.4220, -0.6919, -0.4317, -0.2881, -0.6609]     )
		elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im22k/convnextv2_tiny_22k_384_ema.pt":
				__UpperCAmelCase  :     Any		=    torch.tensor([0.1082, -0.8286, -0.5095, 0.4681, -0.8085]     )
		elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im22k/convnextv2_base_22k_224_ema.pt":
				__UpperCAmelCase  :     Optional[int]		=    torch.tensor([-0.2419, -0.6221, 0.2176, -0.0980, -0.7527]     )
		elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im22k/convnextv2_base_22k_384_ema.pt":
				__UpperCAmelCase  :     Union[str, Any]		=    torch.tensor([0.0391, -0.4371, 0.3786, 0.1251, -0.2784]     )
		elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im22k/convnextv2_large_22k_224_ema.pt":
				__UpperCAmelCase  :     Union[str, Any]		=    torch.tensor([-0.0504, 0.5636, -0.1729, -0.6507, -0.3949]     )
		elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im22k/convnextv2_large_22k_384_ema.pt":
				__UpperCAmelCase  :     Tuple		=    torch.tensor([0.3560, 0.9486, 0.3149, -0.2667, -0.5138]     )
		elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im22k/convnextv2_huge_22k_384_ema.pt":
				__UpperCAmelCase  :     List[Any]		=    torch.tensor([-0.2469, -0.4550, -0.5853, -0.0810, 0.0309]     )
		elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im22k/convnextv2_huge_22k_512_ema.pt":
				__UpperCAmelCase  :     Dict		=    torch.tensor([-0.3090, 0.0802, -0.0682, -0.1979, -0.2826]     )
		else:
				raise ValueError(F"Unknown URL: {checkpoint_url}"     )

		assert torch.allclose(logits[0, :5]						,					snake_case_						,					atol=1e-3     )
		assert logits.shape == expected_shape
		print('Model outputs match the original results!'     )

		if save_model:
				print('Saving model to local...'     )
				# Create folder to save model
				if not os.path.isdir(snake_case_     ):
						os.mkdir(snake_case_     )

				model.save_pretrained(snake_case_     )
				preprocessor.save_pretrained(snake_case_     )

		__UpperCAmelCase  :     Optional[Any]		=    'convnextv2'
		if "atto" in checkpoint_url:
				model_name += "-atto"
		if "femto" in checkpoint_url:
				model_name += "-femto"
		if "pico" in checkpoint_url:
				model_name += "-pico"
		if "nano" in checkpoint_url:
				model_name += "-nano"
		elif "tiny" in checkpoint_url:
				model_name += "-tiny"
		elif "base" in checkpoint_url:
				model_name += "-base"
		elif "large" in checkpoint_url:
				model_name += "-large"
		elif "huge" in checkpoint_url:
				model_name += "-huge"
		if "22k" in checkpoint_url and "1k" not in checkpoint_url:
				model_name += "-22k"
		elif "22k" in checkpoint_url and "1k" in checkpoint_url:
				model_name += "-22k-1k"
		elif "1k" in checkpoint_url:
				model_name += "-1k"
		if "224" in checkpoint_url:
				model_name += "-224"
		elif "384" in checkpoint_url:
				model_name += "-384"
		elif "512" in checkpoint_url:
				model_name += "-512"

		if push_to_hub:
				print(F"Pushing {model_name} to the hub..."     )
				model.push_to_hub(snake_case_     )
				preprocessor.push_to_hub(snake_case_     )


if __name__ == "__main__":
						_SCREAMING_SNAKE_CASE          = argparse.ArgumentParser()
						# Required parameters
						parser.add_argument(
						    '''--checkpoint_url''',
						    default='''https://dl.fbaipublicfiles.com/convnext/convnextv2/im1k/convnextv2_atto_1k_224_ema.pt''',
						    type=str,
						    help='''URL of the original ConvNeXTV2 checkpoint you\'d like to convert.''',
						)
						parser.add_argument(
						    '''--pytorch_dump_folder_path''',
						    default='''model''',
						    type=str,
						    help='''Path to the output PyTorch model directory.''',
						)
						parser.add_argument('''--save_model''', action='''store_true''', help='''Save model to local''')
						parser.add_argument('''--push_to_hub''', action='''store_true''', help='''Push model and image preprocessor to the hub''')

						_SCREAMING_SNAKE_CASE          = parser.parse_args()
						convert_convnextva_checkpoint(
						    args.checkpoint_url, args.pytorch_dump_folder_path, args.save_model, args.push_to_hub
						)








import math
from itertools import permutations





def    _snake_case		(snake_case_				:    int     )       ->		bool:

  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(snake_case_     ) + 1     )						,					6     ):
    if number % i == 0 or number % (i + 2) == 0:
      return False
  return True





def    _snake_case		(snake_case_				:    int						,					snake_case_				:    list     )       ->		bool:
  __UpperCAmelCase, __UpperCAmelCase  :     Any		=    0, len(snake_case_     ) - 1
  while left <= right:
    __UpperCAmelCase  :     List[str]		=    (left + right) // 2
    if prime_list[middle] == target:
      return True
    elif prime_list[middle] < target:
      __UpperCAmelCase  :     Tuple		=    middle + 1
    else:
      __UpperCAmelCase  :     Tuple		=    middle - 1

  return False





def    _snake_case		()       ->		str:
  __UpperCAmelCase  :     List[Any]		=    [n for n in range(1001						,					1_0000						,					2     ) if is_prime(snake_case_     )]
  __UpperCAmelCase  :     Tuple		=    []

  for number in prime_list:
    __UpperCAmelCase  :     List[str]		=    []

    for prime_member in permutations(list(str(snake_case_     )     )     ):
      __UpperCAmelCase  :     Dict		=    int(''.join(snake_case_     )     )

      if prime % 2 == 0:
        continue

      if search(snake_case_						,					snake_case_     ):
        tmp_numbers.append(snake_case_     )

    tmp_numbers.sort()
    if len(snake_case_     ) >= 3:
      candidates.append(snake_case_     )

  __UpperCAmelCase  :     Optional[int]		=    []
  for candidate in candidates:
    __UpperCAmelCase  :     int		=    len(snake_case_     )
    __UpperCAmelCase  :     List[Any]		=    False

    for i in range(snake_case_     ):
      for j in range(i + 1						,					snake_case_     ):
        for k in range(j + 1						,					snake_case_     ):
          if (
              abs(candidate[i] - candidate[j]     )
              == abs(candidate[j] - candidate[k]     )
              and len({candidate[i], candidate[j], candidate[k]}     ) == 3
          ):
            passed.append(
                sorted([candidate[i], candidate[j], candidate[k]]     )     )
            __UpperCAmelCase  :     Any		=    True

          if found:
            break
        if found:
          break
      if found:
        break

  __UpperCAmelCase  :     Dict		=    set()
  for seq in passed:
    answer.add(''.join([str(snake_case_     ) for i in seq]     )     )

  return max(int(snake_case_     ) for x in answer     )


if __name__ == "__main__":
      print(solution())





