





'''simple docstring'''




import argparse
import json
import os

import numpy as np
import PIL
import requests
import tensorflow.keras.applications.efficientnet as efficientnet
import torch
from huggingface_hub import hf_hub_download
from PIL import Image
from tensorflow.keras.preprocessing import image

from transformers import (
    EfficientNetConfig,
    EfficientNetForImageClassification,
    EfficientNetImageProcessor,
)
from transformers.utils import logging


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

__UpperCAmelCase            =       {
    """b0""": efficientnet.EfficientNetBa,
    """b1""": efficientnet.EfficientNetBa,
    """b2""": efficientnet.EfficientNetBa,
    """b3""": efficientnet.EfficientNetBa,
    """b4""": efficientnet.EfficientNetBa,
    """b5""": efficientnet.EfficientNetBa,
    """b6""": efficientnet.EfficientNetBa,
    """b7""": efficientnet.EfficientNetBa,
}

__UpperCAmelCase            =       {
    """b0""": {
        """hidden_dim""": 1280,
        """width_coef""": 1.0,
        """depth_coef""": 1.0,
        """image_size""": 224,
        """dropout_rate""": 0.2,
        """dw_padding""": [],
    },
    """b1""": {
        """hidden_dim""": 1280,
        """width_coef""": 1.0,
        """depth_coef""": 1.1,
        """image_size""": 240,
        """dropout_rate""": 0.2,
        """dw_padding""": [16],
    },
    """b2""": {
        """hidden_dim""": 1408,
        """width_coef""": 1.1,
        """depth_coef""": 1.2,
        """image_size""": 260,
        """dropout_rate""": 0.3,
        """dw_padding""": [5, 8, 16],
    },
    """b3""": {
        """hidden_dim""": 1536,
        """width_coef""": 1.2,
        """depth_coef""": 1.4,
        """image_size""": 300,
        """dropout_rate""": 0.3,
        """dw_padding""": [5, 18],
    },
    """b4""": {
        """hidden_dim""": 1792,
        """width_coef""": 1.4,
        """depth_coef""": 1.8,
        """image_size""": 380,
        """dropout_rate""": 0.4,
        """dw_padding""": [6],
    },
    """b5""": {
        """hidden_dim""": 2048,
        """width_coef""": 1.6,
        """depth_coef""": 2.2,
        """image_size""": 456,
        """dropout_rate""": 0.4,
        """dw_padding""": [13, 27],
    },
    """b6""": {
        """hidden_dim""": 2304,
        """width_coef""": 1.8,
        """depth_coef""": 2.6,
        """image_size""": 528,
        """dropout_rate""": 0.5,
        """dw_padding""": [31],
    },
    """b7""": {
        """hidden_dim""": 2560,
        """width_coef""": 2.0,
        """depth_coef""": 3.1,
        """image_size""": 600,
        """dropout_rate""": 0.5,
        """dw_padding""": [18],
    },
}



def 		__A		(  lowerCamelCase_	):


		"""simple docstring"""



		SCREAMING_SNAKE_CASE :				Optional[Any]		=			EfficientNetConfig()
		SCREAMING_SNAKE_CASE :				str		=			CONFIG_MAP[model_name]["""hidden_dim"""]
		SCREAMING_SNAKE_CASE :				Any		=			CONFIG_MAP[model_name]["""width_coef"""]
		SCREAMING_SNAKE_CASE :				Any		=			CONFIG_MAP[model_name]["""depth_coef"""]
		SCREAMING_SNAKE_CASE :				str		=			CONFIG_MAP[model_name]["""image_size"""]
		SCREAMING_SNAKE_CASE :				List[str]		=			CONFIG_MAP[model_name]["""dropout_rate"""]
		SCREAMING_SNAKE_CASE :				Tuple		=			CONFIG_MAP[model_name]["""dw_padding"""]

		SCREAMING_SNAKE_CASE :				Optional[Any]		=			"""huggingface/label-files"""
		SCREAMING_SNAKE_CASE :				List[str]		=			"""imagenet-1k-id2label.json"""
		SCREAMING_SNAKE_CASE :				Optional[Any]		=			10_00
		SCREAMING_SNAKE_CASE :				str		=			json.load(open(hf_hub_download(lowerCamelCase_			,			lowerCamelCase_			,			repo_type="""dataset"""	)			,			"""r"""	)	)
		SCREAMING_SNAKE_CASE :				List[str]		=			{int(lowerCamelCase_	): v for k, v in idalabel.items()}

		SCREAMING_SNAKE_CASE :				List[Any]		=			idalabel
		SCREAMING_SNAKE_CASE :				List[Any]		=			{v: k for k, v in idalabel.items()}
		return config



def 		__A		(  ):


		"""simple docstring"""



		SCREAMING_SNAKE_CASE :				int		=			"""http://images.cocodataset.org/val2017/000000039769.jpg"""
		SCREAMING_SNAKE_CASE :				List[str]		=			Image.open(requests.get(lowerCamelCase_			,			stream=lowerCamelCase_	).raw	)
		return im



def 		__A		(  lowerCamelCase_	):


		"""simple docstring"""



		SCREAMING_SNAKE_CASE :				Optional[int]		=			CONFIG_MAP[model_name]["""image_size"""]
		SCREAMING_SNAKE_CASE :				int		=			EfficientNetImageProcessor(
		    size={"""height""": size, """width""": size}			,			image_mean=[0.485, 0.456, 0.406]			,			image_std=[0.47_853_944, 0.4_732_864, 0.47_434_163]			,			do_center_crop=lowerCamelCase_			,			)
		return preprocessor



def 		__A		(  lowerCamelCase_	):


		"""simple docstring"""



		SCREAMING_SNAKE_CASE :				Tuple		=			[v.split("""_"""	)[0].split("""block"""	)[1] for v in original_param_names if v.startswith("""block"""	)]
		SCREAMING_SNAKE_CASE :				Tuple		=			sorted(set(lowerCamelCase_	)	)
		SCREAMING_SNAKE_CASE :				Tuple		=			len(lowerCamelCase_	)
		SCREAMING_SNAKE_CASE :				Optional[Any]		=			{b: str(lowerCamelCase_	) for b, i in zip(lowerCamelCase_			,			range(lowerCamelCase_	)	)}

		SCREAMING_SNAKE_CASE :				Optional[Any]		=			[]
		rename_keys.append(("""stem_conv/kernel:0""", """embeddings.convolution.weight""")	)
		rename_keys.append(("""stem_bn/gamma:0""", """embeddings.batchnorm.weight""")	)
		rename_keys.append(("""stem_bn/beta:0""", """embeddings.batchnorm.bias""")	)
		rename_keys.append(("""stem_bn/moving_mean:0""", """embeddings.batchnorm.running_mean""")	)
		rename_keys.append(("""stem_bn/moving_variance:0""", """embeddings.batchnorm.running_var""")	)

		for b in block_names:
				SCREAMING_SNAKE_CASE :				Any		=			block_name_mapping[b]
				rename_keys.append((f'''block{b}_expand_conv/kernel:0''', f'''encoder.blocks.{hf_b}.expansion.expand_conv.weight''')	)
				rename_keys.append((f'''block{b}_expand_bn/gamma:0''', f'''encoder.blocks.{hf_b}.expansion.expand_bn.weight''')	)
				rename_keys.append((f'''block{b}_expand_bn/beta:0''', f'''encoder.blocks.{hf_b}.expansion.expand_bn.bias''')	)
				rename_keys.append(
				    (f'''block{b}_expand_bn/moving_mean:0''', f'''encoder.blocks.{hf_b}.expansion.expand_bn.running_mean''')	)
				rename_keys.append(
				    (f'''block{b}_expand_bn/moving_variance:0''', f'''encoder.blocks.{hf_b}.expansion.expand_bn.running_var''')	)
				rename_keys.append(
				    (f'''block{b}_dwconv/depthwise_kernel:0''', f'''encoder.blocks.{hf_b}.depthwise_conv.depthwise_conv.weight''')	)
				rename_keys.append((f'''block{b}_bn/gamma:0''', f'''encoder.blocks.{hf_b}.depthwise_conv.depthwise_norm.weight''')	)
				rename_keys.append((f'''block{b}_bn/beta:0''', f'''encoder.blocks.{hf_b}.depthwise_conv.depthwise_norm.bias''')	)
				rename_keys.append(
				    (f'''block{b}_bn/moving_mean:0''', f'''encoder.blocks.{hf_b}.depthwise_conv.depthwise_norm.running_mean''')	)
				rename_keys.append(
				    (f'''block{b}_bn/moving_variance:0''', f'''encoder.blocks.{hf_b}.depthwise_conv.depthwise_norm.running_var''')	)

				rename_keys.append((f'''block{b}_se_reduce/kernel:0''', f'''encoder.blocks.{hf_b}.squeeze_excite.reduce.weight''')	)
				rename_keys.append((f'''block{b}_se_reduce/bias:0''', f'''encoder.blocks.{hf_b}.squeeze_excite.reduce.bias''')	)
				rename_keys.append((f'''block{b}_se_expand/kernel:0''', f'''encoder.blocks.{hf_b}.squeeze_excite.expand.weight''')	)
				rename_keys.append((f'''block{b}_se_expand/bias:0''', f'''encoder.blocks.{hf_b}.squeeze_excite.expand.bias''')	)
				rename_keys.append(
				    (f'''block{b}_project_conv/kernel:0''', f'''encoder.blocks.{hf_b}.projection.project_conv.weight''')	)
				rename_keys.append((f'''block{b}_project_bn/gamma:0''', f'''encoder.blocks.{hf_b}.projection.project_bn.weight''')	)
				rename_keys.append((f'''block{b}_project_bn/beta:0''', f'''encoder.blocks.{hf_b}.projection.project_bn.bias''')	)
				rename_keys.append(
				    (f'''block{b}_project_bn/moving_mean:0''', f'''encoder.blocks.{hf_b}.projection.project_bn.running_mean''')	)
				rename_keys.append(
				    (f'''block{b}_project_bn/moving_variance:0''', f'''encoder.blocks.{hf_b}.projection.project_bn.running_var''')	)

		rename_keys.append(("""top_conv/kernel:0""", """encoder.top_conv.weight""")	)
		rename_keys.append(("""top_bn/gamma:0""", """encoder.top_bn.weight""")	)
		rename_keys.append(("""top_bn/beta:0""", """encoder.top_bn.bias""")	)
		rename_keys.append(("""top_bn/moving_mean:0""", """encoder.top_bn.running_mean""")	)
		rename_keys.append(("""top_bn/moving_variance:0""", """encoder.top_bn.running_var""")	)

		SCREAMING_SNAKE_CASE :				Optional[Any]		=			{}
		for item in rename_keys:
				if item[0] in original_param_names:
						SCREAMING_SNAKE_CASE :				Tuple		=			"""efficientnet.""" + item[1]

		SCREAMING_SNAKE_CASE :				str		=			"""classifier.weight"""
		SCREAMING_SNAKE_CASE :				List[str]		=			"""classifier.bias"""
		return key_mapping



def 		__A		(  lowerCamelCase_			,			lowerCamelCase_			,			lowerCamelCase_	):


		"""simple docstring"""



		for key, value in tf_params.items():
				if "normalization" in key:
						continue

				SCREAMING_SNAKE_CASE :				Tuple		=			key_mapping[key]
				if "_conv" in key and "kernel" in key:
						SCREAMING_SNAKE_CASE :				Optional[int]		=			torch.from_numpy(lowerCamelCase_	).permute(3			,			2			,			0			,			1	)
				elif "depthwise_kernel" in key:
						SCREAMING_SNAKE_CASE :				Union[str, Any]		=			torch.from_numpy(lowerCamelCase_	).permute(2			,			3			,			0			,			1	)
				elif "kernel" in key:
						SCREAMING_SNAKE_CASE :				Any		=			torch.from_numpy(np.transpose(lowerCamelCase_	)	)
				else:
						SCREAMING_SNAKE_CASE :				Any		=			torch.from_numpy(lowerCamelCase_	)

				# Replace HF parameters with original TF model parameters
				assert hf_params[hf_key].shape == new_hf_value.shape
				hf_params[hf_key].copy_(lowerCamelCase_	)



@torch.no_grad()
def 		__A		(  lowerCamelCase_			,			lowerCamelCase_			,			lowerCamelCase_			,			lowerCamelCase_	):


		"""simple docstring"""



		SCREAMING_SNAKE_CASE :				Dict		=			model_classes[model_name](
		    include_top=lowerCamelCase_			,			weights="""imagenet"""			,			input_tensor=lowerCamelCase_			,			input_shape=lowerCamelCase_			,			pooling=lowerCamelCase_			,			classes=10_00			,			classifier_activation="""softmax"""			,			)

		SCREAMING_SNAKE_CASE :				List[str]		=			original_model.trainable_variables
		SCREAMING_SNAKE_CASE :				str		=			original_model.non_trainable_variables
		SCREAMING_SNAKE_CASE :				Dict		=			{param.name: param.numpy() for param in tf_params}
		for param in tf_non_train_params:
				SCREAMING_SNAKE_CASE :				List[str]		=			param.numpy()
		SCREAMING_SNAKE_CASE :				List[str]		=			list(tf_params.keys()	)

		# Load HuggingFace model
		SCREAMING_SNAKE_CASE :				Optional[int]		=			get_efficientnet_config(lowerCamelCase_	)
		SCREAMING_SNAKE_CASE :				Tuple		=			EfficientNetForImageClassification(lowerCamelCase_	).eval()
		SCREAMING_SNAKE_CASE :				Optional[Any]		=			hf_model.state_dict()

		# Create src-to-dst parameter name mapping dictionary
		print("""Converting parameters..."""	)
		SCREAMING_SNAKE_CASE :				int		=			rename_keys(lowerCamelCase_	)
		replace_params(lowerCamelCase_			,			lowerCamelCase_			,			lowerCamelCase_	)

		# Initialize preprocessor and preprocess input image
		SCREAMING_SNAKE_CASE :				Dict		=			convert_image_processor(lowerCamelCase_	)
		SCREAMING_SNAKE_CASE :				Tuple		=			preprocessor(images=prepare_img()			,			return_tensors="""pt"""	)

		# HF model inference
		hf_model.eval()
		with torch.no_grad():
				SCREAMING_SNAKE_CASE :				Union[str, Any]		=			hf_model(**lowerCamelCase_	)
		SCREAMING_SNAKE_CASE :				List[Any]		=			outputs.logits.detach().numpy()

		# Original model inference
		SCREAMING_SNAKE_CASE :				str		=			False
		SCREAMING_SNAKE_CASE :				Union[str, Any]		=			CONFIG_MAP[model_name]["""image_size"""]
		SCREAMING_SNAKE_CASE :				Optional[int]		=			prepare_img().resize((image_size, image_size)			,			resample=PIL.Image.NEAREST	)
		SCREAMING_SNAKE_CASE :				Any		=			image.img_to_array(lowerCamelCase_	)
		SCREAMING_SNAKE_CASE :				Tuple		=			np.expand_dims(lowerCamelCase_			,			axis=0	)
		SCREAMING_SNAKE_CASE :				Dict		=			original_model.predict(lowerCamelCase_	)

		# Check whether original and HF model outputs match  -> np.allclose
		assert np.allclose(lowerCamelCase_			,			lowerCamelCase_			,			atol=1E-3	), "The predicted logits are not the same."
		print("""Model outputs match!"""	)

		if save_model:
				# Create folder to save model
				if not os.path.isdir(lowerCamelCase_	):
						os.mkdir(lowerCamelCase_	)
				# Save converted model and image processor
				hf_model.save_pretrained(lowerCamelCase_	)
				preprocessor.save_pretrained(lowerCamelCase_	)

		if push_to_hub:
				# Push model and image processor to hub
				print(f'''Pushing converted {model_name} to the hub...'''	)
				SCREAMING_SNAKE_CASE :				Any		=			f'''efficientnet-{model_name}'''
				preprocessor.push_to_hub(lowerCamelCase_	)
				hf_model.push_to_hub(lowerCamelCase_	)


if __name__ == "__main__":
							__UpperCAmelCase            =       argparse.ArgumentParser()
							# Required parameters
							parser.add_argument(
							    """--model_name""",
							    default="""b0""",
							    type=str,
							    help="""Version name of the EfficientNet model you want to convert, select from [b0, b1, b2, b3, b4, b5, b6, b7].""",
							)
							parser.add_argument(
							    """--pytorch_dump_folder_path""",
							    default="""hf_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 processor to the hub""")

							__UpperCAmelCase            =       parser.parse_args()
							convert_efficientnet_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.save_model, args.push_to_hub)










'''simple docstring'''




from math import sqrt



def 		__A		(  lowerCamelCase_	):


		"""simple docstring"""



		SCREAMING_SNAKE_CASE :				str		=			0
		for i in range(1			,			int(sqrt(lowerCamelCase_	) + 1	)	):
				if n % i == 0 and i != sqrt(lowerCamelCase_	):
						total += i + n // i
				elif i == sqrt(lowerCamelCase_	):
						total += i
		return total - n



def 		__A		(  lowerCamelCase_ = 1_00_00	):


		"""simple docstring"""



		SCREAMING_SNAKE_CASE :				str		=			sum(
		    i
		    for i in range(1			,			lowerCamelCase_	)
		    if sum_of_divisors(sum_of_divisors(lowerCamelCase_	)	) == i and sum_of_divisors(lowerCamelCase_	) != i	)
		return total


if __name__ == "__main__":
							print(solution(int(str(input()).strip())))



