


"""simple docstring"""
import argparse
import json
import os

import torch
from torch import nn

from transformers import NllbMoeConfig, NllbMoeModel
from transformers.modeling_utils import dtype_byte_size
from transformers.utils import WEIGHTS_INDEX_NAME, WEIGHTS_NAME






def 		lowercase							(     _snake_case						:      str     )     ->Tuple:
	"""simple docstring"""





	__snake_case	:						Tuple						=				[
	    '''encoder.version''',
	    '''decoder.version''',
	    '''model.encoder.version''',
	    '''model.decoder.version''',
	    '''decoder.output_projection.weight''',
	    '''_float_tensor''',
	    '''encoder.embed_positions._float_tensor''',
	    '''decoder.embed_positions._float_tensor''',
	]
	for k in ignore_keys:
		state_dict.pop(_snake_case     ,   _snake_case     )






def 		lowercase							(     _snake_case						:      Tuple     )     ->Tuple:
	"""simple docstring"""





	__snake_case	,							__snake_case	:						str						=				emb.weight.shape
	__snake_case	:						int						=				nn.Linear(_snake_case     ,   _snake_case     ,   bias=_snake_case     )
	__snake_case	:						Union[str, Any]						=				emb.weight.data
	return lin_layer






def 		lowercase							(     _snake_case						:      List[Any]     ,   _snake_case						:      Tuple=None     )     ->Dict:
	"""simple docstring"""





	__snake_case	:						Optional[Any]						=				{}
	for old_key in state_dict.keys():
		__snake_case	:						List[Any]						=				old_key
		if "moe_layer.experts." in key:
			if expert_idx is not None:
				__snake_case	:						Optional[int]						=				key.replace('''moe_layer.experts.0'''     ,   f"""ffn.experts.expert_{expert_idx}"""     )
			else:
				__snake_case	:						Tuple						=				key.replace('''moe_layer.experts.'''     ,   '''ffn.experts.expert_'''     )
		if "gate" in key:
			__snake_case	:						Union[str, Any]						=				key.replace('''.moe_layer.gate.wg'''     ,   '''.ffn.router.classifier'''     )
		if "fc2" and "experts" not in key:
			__snake_case	:						List[Any]						=				key.replace('''.fc2.'''     ,   '''.ffn.fc2.'''     )
		if "fc1" and "experts" not in key:
			__snake_case	:						Union[str, Any]						=				key.replace('''.fc1.'''     ,   '''.ffn.fc1.'''     )
		if ".encoder_attn." in key:
			__snake_case	:						Optional[int]						=				key.replace('''.encoder_attn.'''     ,   '''.cross_attention.'''     )
		if "encoder_attn_layer_norm" in key:
			__snake_case	:						int						=				key.replace('''encoder_attn_layer_norm'''     ,   '''cross_attention_layer_norm'''     )
		if "final_layer_norm" in key:
			__snake_case	:						List[str]						=				key.replace('''final_layer_norm'''     ,   '''ff_layer_norm'''     )
		__snake_case	:						Union[str, Any]						=				state_dict[old_key]
	return new_dict






def 		lowercase							(     _snake_case						:      List[Any]     ,   _snake_case						:      Union[str, Any]     ,   _snake_case						:      str     ,   _snake_case						:      int     ,   _snake_case						:      str = WEIGHTS_NAME     )     ->Tuple:
	"""simple docstring"""





	__snake_case	:						int						=				[]
	__snake_case	:						Any						=				0
	os.makedirs(_snake_case     ,   exist_ok=_snake_case     )

	for expert in range(_snake_case     ):
		__snake_case	:						Tuple						=				switch_checkpoint_path + f"""-rank-{expert}.pt"""
		if os.path.isfile(_snake_case     ):
			__snake_case	:						Dict						=				torch.load(_snake_case     )['''model''']
			remove_ignore_keys_(_snake_case     )
			__snake_case	:						str						=				rename_fairseq_keys(_snake_case     ,   _snake_case     )
			__snake_case	:						Union[str, Any]						=				os.path.join(
			    _snake_case     ,   weights_name.replace('''.bin'''     ,   f"""-{len(_snake_case     )+1:05d}-of-???.bin"""     )     )
			torch.save(_snake_case     ,   _snake_case     )
			sharded_state_dicts.append(expert_state.keys()     )
			total_size += sum([value.numel() for key, value in expert_state.items()]     ) * dtype_byte_size(
			    expert_state[list(_snake_case     )[0]].dtype     )

    # Add the last block
	__snake_case	:						Dict						=				os.path.join(_snake_case     ,   weights_name.replace('''.bin'''     ,   f"""-{len(_snake_case     )+1:05d}-of-???.bin"""     )     )
	__snake_case	:						Optional[Any]						=				torch.load(switch_checkpoint_path + '''-shared.pt'''     )['''model''']
	remove_ignore_keys_(_snake_case     )
	__snake_case	:						str						=				rename_fairseq_keys(_snake_case     ,   _snake_case     )
	__snake_case	:						Any						=				shared_weights['''decoder.embed_tokens.weight''']
	sharded_state_dicts.append(shared_weights.keys()     )

	# If we only have the shared weights (dummy model/experts saved on the same file)
	if len(_snake_case     ) == 1:
		__snake_case	:						List[str]						=				os.path.join(_snake_case     ,   _snake_case     )
		torch.save(_snake_case     ,   _snake_case     )
		return {weights_name: sharded_state_dicts[0]}, None
	else:
		torch.save(_snake_case     ,   _snake_case     )
	# Otherwise, let's build the index
	__snake_case	:						Union[str, Any]						=				{}
	for idx, shard in enumerate(_snake_case     ):
		__snake_case	:						Dict						=				weights_name.replace('''.bin'''     ,   f"""-{idx+1:05d}-of-{len(_snake_case     ):05d}.bin"""     )
		__snake_case	:						List[Any]						=				os.path.join(_snake_case     ,   weights_name.replace('''.bin'''     ,   f"""-{idx+1:05d}-of-???.bin"""     )     )
		os.rename(_snake_case     ,   os.path.join(_snake_case     ,   _snake_case     )     )
		for key in shard:
			__snake_case	:						List[str]						=				shard_file

    # Add the metadata
	__snake_case	:						Dict						=				{'''total_size''': total_size}
	__snake_case	:						Dict						=				{'''metadata''': metadata, '''weight_map''': weight_map}

	with open(os.path.join(_snake_case     ,   _snake_case     )     ,   '''w'''     ,   encoding='''utf-8'''     ) as f:
		__snake_case	:						Optional[Any]						=				json.dumps(_snake_case     ,   indent=2     ,   sort_keys=_snake_case     ) + '''\n'''
		f.write(_snake_case     )

	return metadata, index


if __name__ == "__main__":
			SCREAMING_SNAKE_CASE :    Any									=				argparse.ArgumentParser()
			# Required parameters
			parser.add_argument(
			    """--nllb_moe_checkpoint_path""",
			    default="""/home/arthur_huggingface_co/fairseq/weights/checkpoints/model_moe_54b/checkpoint_2_300000""",
			    type=str,
			    required=False,
			    help="""Path to a directory containing a folder per layer. Follows the original Google format.""",
			)
			parser.add_argument("""--dtype""", default="""float32""", type=str, required=False, help="""dtype of the saved model""")
			parser.add_argument(
			    """--pytorch_dump_folder_path""",
			    default="""/home/arthur_huggingface_co/fairseq/weights/checkpoints/hf-converted-moe-54b""",
			    type=str,
			    required=False,
			    help="""Path to the output pytorch model.""",
			)
			SCREAMING_SNAKE_CASE :    Tuple									=				parser.parse_args()
			SCREAMING_SNAKE_CASE					,  SCREAMING_SNAKE_CASE :    List[Any]									=				shard_on_the_fly(
			    args.nllb_moe_checkpoint_path,
			    args.pytorch_dump_folder_path,
			    128,
			    args.dtype,
			)

			SCREAMING_SNAKE_CASE :    Any									=				NllbMoeConfig.from_pretrained(
			    """facebook/nllb-200-3.3B""", encoder_sparse_step=4, decoder_sparse_step=4, num_experts=128
			)
			config.save_pretrained(args.pytorch_dump_folder_path)
			SCREAMING_SNAKE_CASE :    Dict									=				NllbMoeModel.from_pretrained(args.pytorch_dump_folder_path)
			print("""Done""")
			model.save_pretrained(args.pytorch_dump_folder_path)









"""simple docstring"""
from __future__ import annotations






def 		lowercase							(     _snake_case						:      int | str     )     ->bool:
	"""simple docstring"""





	__snake_case	:						List[str]						=				str(_snake_case     )
	return n == n[::-1]






def 		lowercase							(     _snake_case						:      int = 1_000_000     )     ->str:
	"""simple docstring"""





	__snake_case	:						Union[str, Any]						=				0

	for i in range(1     ,   _snake_case     ):
		if is_palindrome(_snake_case     ) and is_palindrome(bin(_snake_case     ).split('''b'''     )[1]     ):
			total += i
	return total


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





