



import argparse
import json
from collections import OrderedDict

import torch
from huggingface_hub import cached_download, hf_hub_url

from transformers import AutoImageProcessor, CvtConfig, CvtForImageClassification



def       lowercase       (   SCREAMING_SNAKE_CASE__       :	Any				)  ->     Optional[int]:
	_snake_case    :  List[Any]					=					[]
	embed.append(
	    (
	        F'''cvt.encoder.stages.{idx}.embedding.convolution_embeddings.projection.weight''',
	        F'''stage{idx}.patch_embed.proj.weight''',
	    )				)
	embed.append(
	    (
	        F'''cvt.encoder.stages.{idx}.embedding.convolution_embeddings.projection.bias''',
	        F'''stage{idx}.patch_embed.proj.bias''',
	    )				)
	embed.append(
	    (
	        F'''cvt.encoder.stages.{idx}.embedding.convolution_embeddings.normalization.weight''',
	        F'''stage{idx}.patch_embed.norm.weight''',
	    )				)
	embed.append(
	    (
	        F'''cvt.encoder.stages.{idx}.embedding.convolution_embeddings.normalization.bias''',
	        F'''stage{idx}.patch_embed.norm.bias''',
	    )				)
	return embed



def       lowercase       (   SCREAMING_SNAKE_CASE__       :	List[str]				,       SCREAMING_SNAKE_CASE__       :	Optional[int]				)  ->     Union[str, Any]:
	_snake_case    :  List[Any]					=					[]
	attention_weights.append(
	    (
	        F'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_query.convolution_projection.convolution.weight''',
	        F'''stage{idx}.blocks.{cnt}.attn.conv_proj_q.conv.weight''',
	    )				)
	attention_weights.append(
	    (
	        F'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_query.convolution_projection.normalization.weight''',
	        F'''stage{idx}.blocks.{cnt}.attn.conv_proj_q.bn.weight''',
	    )				)
	attention_weights.append(
	    (
	        F'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_query.convolution_projection.normalization.bias''',
	        F'''stage{idx}.blocks.{cnt}.attn.conv_proj_q.bn.bias''',
	    )				)
	attention_weights.append(
	    (
	        F'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_query.convolution_projection.normalization.running_mean''',
	        F'''stage{idx}.blocks.{cnt}.attn.conv_proj_q.bn.running_mean''',
	    )				)
	attention_weights.append(
	    (
	        F'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_query.convolution_projection.normalization.running_var''',
	        F'''stage{idx}.blocks.{cnt}.attn.conv_proj_q.bn.running_var''',
	    )				)
	attention_weights.append(
	    (
	        F'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_query.convolution_projection.normalization.num_batches_tracked''',
	        F'''stage{idx}.blocks.{cnt}.attn.conv_proj_q.bn.num_batches_tracked''',
	    )				)
	attention_weights.append(
	    (
	        F'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_key.convolution_projection.convolution.weight''',
	        F'''stage{idx}.blocks.{cnt}.attn.conv_proj_k.conv.weight''',
	    )				)
	attention_weights.append(
	    (
	        F'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_key.convolution_projection.normalization.weight''',
	        F'''stage{idx}.blocks.{cnt}.attn.conv_proj_k.bn.weight''',
	    )				)
	attention_weights.append(
	    (
	        F'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_key.convolution_projection.normalization.bias''',
	        F'''stage{idx}.blocks.{cnt}.attn.conv_proj_k.bn.bias''',
	    )				)
	attention_weights.append(
	    (
	        F'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_key.convolution_projection.normalization.running_mean''',
	        F'''stage{idx}.blocks.{cnt}.attn.conv_proj_k.bn.running_mean''',
	    )				)
	attention_weights.append(
	    (
	        F'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_key.convolution_projection.normalization.running_var''',
	        F'''stage{idx}.blocks.{cnt}.attn.conv_proj_k.bn.running_var''',
	    )				)
	attention_weights.append(
	    (
	        F'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_key.convolution_projection.normalization.num_batches_tracked''',
	        F'''stage{idx}.blocks.{cnt}.attn.conv_proj_k.bn.num_batches_tracked''',
	    )				)
	attention_weights.append(
	    (
	        F'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_value.convolution_projection.convolution.weight''',
	        F'''stage{idx}.blocks.{cnt}.attn.conv_proj_v.conv.weight''',
	    )				)
	attention_weights.append(
	    (
	        F'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_value.convolution_projection.normalization.weight''',
	        F'''stage{idx}.blocks.{cnt}.attn.conv_proj_v.bn.weight''',
	    )				)
	attention_weights.append(
	    (
	        F'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_value.convolution_projection.normalization.bias''',
	        F'''stage{idx}.blocks.{cnt}.attn.conv_proj_v.bn.bias''',
	    )				)
	attention_weights.append(
	    (
	        F'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_value.convolution_projection.normalization.running_mean''',
	        F'''stage{idx}.blocks.{cnt}.attn.conv_proj_v.bn.running_mean''',
	    )				)
	attention_weights.append(
	    (
	        F'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_value.convolution_projection.normalization.running_var''',
	        F'''stage{idx}.blocks.{cnt}.attn.conv_proj_v.bn.running_var''',
	    )				)
	attention_weights.append(
	    (
	        F'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_value.convolution_projection.normalization.num_batches_tracked''',
	        F'''stage{idx}.blocks.{cnt}.attn.conv_proj_v.bn.num_batches_tracked''',
	    )				)
	attention_weights.append(
	    (
	        F'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.projection_query.weight''',
	        F'''stage{idx}.blocks.{cnt}.attn.proj_q.weight''',
	    )				)
	attention_weights.append(
	    (
	        F'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.projection_query.bias''',
	        F'''stage{idx}.blocks.{cnt}.attn.proj_q.bias''',
	    )				)
	attention_weights.append(
	    (
	        F'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.projection_key.weight''',
	        F'''stage{idx}.blocks.{cnt}.attn.proj_k.weight''',
	    )				)
	attention_weights.append(
	    (
	        F'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.projection_key.bias''',
	        F'''stage{idx}.blocks.{cnt}.attn.proj_k.bias''',
	    )				)
	attention_weights.append(
	    (
	        F'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.projection_value.weight''',
	        F'''stage{idx}.blocks.{cnt}.attn.proj_v.weight''',
	    )				)
	attention_weights.append(
	    (
	        F'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.projection_value.bias''',
	        F'''stage{idx}.blocks.{cnt}.attn.proj_v.bias''',
	    )				)
	attention_weights.append(
	    (
	        F'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.output.dense.weight''',
	        F'''stage{idx}.blocks.{cnt}.attn.proj.weight''',
	    )				)
	attention_weights.append(
	    (
	        F'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.output.dense.bias''',
	        F'''stage{idx}.blocks.{cnt}.attn.proj.bias''',
	    )				)
	attention_weights.append(
	    (F'''cvt.encoder.stages.{idx}.layers.{cnt}.intermediate.dense.weight''', F'''stage{idx}.blocks.{cnt}.mlp.fc1.weight''')				)
	attention_weights.append(
	    (F'''cvt.encoder.stages.{idx}.layers.{cnt}.intermediate.dense.bias''', F'''stage{idx}.blocks.{cnt}.mlp.fc1.bias''')				)
	attention_weights.append(
	    (F'''cvt.encoder.stages.{idx}.layers.{cnt}.output.dense.weight''', F'''stage{idx}.blocks.{cnt}.mlp.fc2.weight''')				)
	attention_weights.append(
	    (F'''cvt.encoder.stages.{idx}.layers.{cnt}.output.dense.bias''', F'''stage{idx}.blocks.{cnt}.mlp.fc2.bias''')				)
	attention_weights.append(
	    (F'''cvt.encoder.stages.{idx}.layers.{cnt}.layernorm_before.weight''', F'''stage{idx}.blocks.{cnt}.norm1.weight''')				)
	attention_weights.append(
	    (F'''cvt.encoder.stages.{idx}.layers.{cnt}.layernorm_before.bias''', F'''stage{idx}.blocks.{cnt}.norm1.bias''')				)
	attention_weights.append(
	    (F'''cvt.encoder.stages.{idx}.layers.{cnt}.layernorm_after.weight''', F'''stage{idx}.blocks.{cnt}.norm2.weight''')				)
	attention_weights.append(
	    (F'''cvt.encoder.stages.{idx}.layers.{cnt}.layernorm_after.bias''', F'''stage{idx}.blocks.{cnt}.norm2.bias''')				)
	return attention_weights



def       lowercase       (   SCREAMING_SNAKE_CASE__       :	Dict				)  ->     int:
	_snake_case    :  int					=					[]
	token.append((F'''cvt.encoder.stages.{idx}.cls_token''', """stage2.cls_token""")				)
	return token



def       lowercase       (   )  ->     Optional[int]:
	_snake_case    :  str					=					[]
	head.append(("""layernorm.weight""", """norm.weight""")				)
	head.append(("""layernorm.bias""", """norm.bias""")				)
	head.append(("""classifier.weight""", """head.weight""")				)
	head.append(("""classifier.bias""", """head.bias""")				)
	return head



def       lowercase       (   SCREAMING_SNAKE_CASE__       :	Tuple				,       SCREAMING_SNAKE_CASE__       :	Any				,       SCREAMING_SNAKE_CASE__       :	str				,       SCREAMING_SNAKE_CASE__       :	str				)  ->     Union[str, Any]:
	_snake_case    :  str					=					"""imagenet-1k-id2label.json"""
	_snake_case    :  List[str]					=					1_000

	_snake_case    :  Any					=					"""huggingface/label-files"""
	_snake_case    :  Optional[Any]					=					num_labels
	_snake_case    :  Union[str, Any]					=					json.load(open(cached_download(hf_hub_url(SCREAMING_SNAKE_CASE__				,       SCREAMING_SNAKE_CASE__				,       repo_type="""dataset"""				)				)				,       """r"""				)				)
	_snake_case    :  Union[str, Any]					=					{int(SCREAMING_SNAKE_CASE__				): v for k, v in idalabel.items()}

	_snake_case    :  Optional[int]					=					idalabel
	_snake_case    :  List[Any]					=					{v: k for k, v in idalabel.items()}

	_snake_case    :  Optional[int]					=					CvtConfig(num_labels=SCREAMING_SNAKE_CASE__				,       idalabel=SCREAMING_SNAKE_CASE__				,       labelaid=SCREAMING_SNAKE_CASE__				)

	# For depth size 13 (13 = 1+2+10)
	if cvt_model.rsplit("""/"""				,       1				)[-1][4:6] == "13":
		_snake_case    :  Any					=					[1, 2, 10]

	# For depth size 21 (21 = 1+4+16)
	elif cvt_model.rsplit("""/"""				,       1				)[-1][4:6] == "21":
		_snake_case    :  Optional[int]					=					[1, 4, 16]

	# For wide cvt (similar to wide-resnet) depth size 24 (w24 = 2 + 2 20)
	else:
		_snake_case    :  Optional[int]					=					[2, 2, 20]
		_snake_case    :  int					=					[3, 12, 16]
		_snake_case    :  List[str]					=					[192, 768, 1_024]

	_snake_case    :  Union[str, Any]					=					CvtForImageClassification(SCREAMING_SNAKE_CASE__				)
	_snake_case    :  Optional[int]					=					AutoImageProcessor.from_pretrained("""facebook/convnext-base-224-22k-1k"""				)
	_snake_case    :  Union[str, Any]					=					image_size
	_snake_case    :  str					=					torch.load(SCREAMING_SNAKE_CASE__				,       map_location=torch.device("""cpu"""				)				)

	_snake_case    :  List[str]					=					OrderedDict()
	_snake_case    :  Optional[Any]					=					[]

	for idx in range(len(config.depth				)				):
		if config.cls_token[idx]:
			_snake_case    :  List[str]					=					list_of_state_dict + cls_token(SCREAMING_SNAKE_CASE__				)
		_snake_case    :  Union[str, Any]					=					list_of_state_dict + embeddings(SCREAMING_SNAKE_CASE__				)
		for cnt in range(config.depth[idx]				):
			_snake_case    :  Optional[Any]					=					list_of_state_dict + attention(SCREAMING_SNAKE_CASE__				,       SCREAMING_SNAKE_CASE__				)

	_snake_case    :  int					=					list_of_state_dict + final()
	for gg in list_of_state_dict:
		print(SCREAMING_SNAKE_CASE__				)
	for i in range(len(SCREAMING_SNAKE_CASE__				)				):
		_snake_case    :  List[Any]					=					original_weights[list_of_state_dict[i][1]]

	model.load_state_dict(SCREAMING_SNAKE_CASE__				)
	model.save_pretrained(SCREAMING_SNAKE_CASE__				)
	image_processor.save_pretrained(SCREAMING_SNAKE_CASE__				)


# Download the weights from zoo: https://1drv.ms/u/s!AhIXJn_J-blW9RzF3rMW7SsLHa8h?e=blQ0Al

if __name__ == "__main__":
		a__    =	argparse.ArgumentParser()
		parser.add_argument(
		    """--cvt_model""",
		    default="""cvt-w24""",
		    type=str,
		    help="""Name of the cvt model you'd like to convert.""",
		)
		parser.add_argument(
		    """--image_size""",
		    default=3_84,
		    type=int,
		    help="""Input Image Size""",
		)
		parser.add_argument(
		    """--cvt_file_name""",
		    default=R"""cvtmodels\CvT-w24-384x384-IN-22k.pth""",
		    type=str,
		    help="""Input Image Size""",
		)
		parser.add_argument(
		    """--pytorch_dump_folder_path""", default=None, type=str, help="""Path to the output PyTorch model directory."""
		)

		a__    =	parser.parse_args()
		convert_cvt_checkpoint(args.cvt_model, args.image_size, args.cvt_file_name, args.pytorch_dump_folder_path)





def       lowercase       (   SCREAMING_SNAKE_CASE__       :	int = 1_000				)  ->     int:
 _snake_case	,    _snake_case    :  str					=					1, 1
 _snake_case    :  List[Any]					=					2
 while True:
  _snake_case    :  Union[str, Any]					=					0
  _snake_case    :  int					=					fa + fa
  _snake_case	,    _snake_case    :  Union[str, Any]					=					fa, f
  index += 1
  for _ in str(SCREAMING_SNAKE_CASE__				):
   i += 1
  if i == n:
   break
 return index


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