



"""simple docstring"""






import argparse
from pathlib import Path

import torch

from transformers import OPTConfig, OPTModel
from transformers.utils import logging


logging.set_verbosity_info()
__snake_case							:   Tuple      =    logging.get_logger(__name__)


def 			_lowercase				(  __snake_case	)						->   List[Any]:
			__lowerCAmelCase      :  Tuple												=       torch.load(__snake_case					,map_location="cpu"	)
			if "model" in sd.keys():
						__lowerCAmelCase      :  Any												=       torch.load(__snake_case					,map_location="cpu"	)["model"]

			# pop unnecessary weights
			__lowerCAmelCase      :  List[Any]												=       [
			    "decoder.version",
			    "decoder.output_projection.weight",
			]
			for key in keys_to_delete:
						if key in sd:
									sd.pop(__snake_case	)

			__lowerCAmelCase      :  Dict												=       {
			    "decoder.project_in_dim.weight": "decoder.project_in.weight",
			    "decoder.project_out_dim.weight": "decoder.project_out.weight",
			    "decoder.layer_norm.weight": "decoder.final_layer_norm.weight",
			    "decoder.layer_norm.bias": "decoder.final_layer_norm.bias",
			}
			for old_key, new_key in keys_to_rename.items():
						if old_key in sd:
									__lowerCAmelCase      :  Union[str, Any]												=       sd.pop(__snake_case	)

			__lowerCAmelCase      :  Tuple												=       list(sd.keys()	)
			for key in keys:
						if ".qkv_proj." in key:
									__lowerCAmelCase      :  str												=       sd[key]
									# We split QKV in separate Q,K,V

									__lowerCAmelCase      :  Any												=       key.replace(".qkv_proj."					,".q_proj."	)
									__lowerCAmelCase      :  List[str]												=       key.replace(".qkv_proj."					,".k_proj."	)
									__lowerCAmelCase      :  Optional[Any]												=       key.replace(".qkv_proj."					,".v_proj."	)

									__lowerCAmelCase      :  Optional[Any]												=       value.shape[0]
									assert depth % 3 == 0
									# `SequeuceParallelTransformerBlock` has QKV weight is separated in K,V,Q despite the naming:
									# https://cs.github.com/facebookresearch/metaseq/blob/51871bd73cd04c038f239ea2a26db1d7f6b37927/metaseq/modules/sequence_parallel_transformer_layer.py#L97
									__lowerCAmelCase						,	__lowerCAmelCase						,	__lowerCAmelCase      :  Optional[int]												=       torch.split(__snake_case					,depth // 3					,dim=0	)

									__lowerCAmelCase      :  Optional[Any]												=       q
									__lowerCAmelCase      :  Any												=       k
									__lowerCAmelCase      :  Optional[int]												=       v
									del sd[key]

			return sd


@torch.no_grad()
def 			_lowercase				(  __snake_case					,__snake_case					,__snake_case=None	)						->   int:
			__lowerCAmelCase      :  Optional[Any]												=       load_checkpoint(__snake_case	)

			if config is not None:
						__lowerCAmelCase      :  str												=       OPTConfig.from_pretrained(__snake_case	)
			else:
						__lowerCAmelCase      :  str												=       OPTConfig()

			__lowerCAmelCase      :  int												=       OPTModel(__snake_case	).half().eval()
			model.load_state_dict(__snake_case	)

			# Check results
			Path(__snake_case	).mkdir(exist_ok=__snake_case	)
			model.save_pretrained(__snake_case	)


if __name__ == "__main__":
	__snake_case							:   int      =    argparse.ArgumentParser()
	# Required parameters
	parser.add_argument(
	    '--fairseq_path',
	    type=str,
	    help=(
	        'path to fairseq checkpoint in correct format. You can find all checkpoints in the correct format here:'
	        ' https://huggingface.co/models?other=opt_metasq'
	    ),
	)
	parser.add_argument('--pytorch_dump_folder_path', default=None, type=str, help='Path to the output PyTorch model.')
	parser.add_argument('--hf_config', default=None, type=str, help='Define HF config.')
	__snake_case							:   Dict      =    parser.parse_args()
	convert_opt_checkpoint(args.fairseq_path, args.pytorch_dump_folder_path, config=args.hf_config)




"""simple docstring"""






def 			_lowercase				(  )						->   int:
			return 1


def 			_lowercase				(  __snake_case	)						->   int:
			return 0 if x < 0 else two_pence(x - 2	) + one_pence()


def 			_lowercase				(  __snake_case	)						->   int:
			return 0 if x < 0 else five_pence(x - 5	) + two_pence(__snake_case	)


def 			_lowercase				(  __snake_case	)						->   int:
			return 0 if x < 0 else ten_pence(x - 10	) + five_pence(__snake_case	)


def 			_lowercase				(  __snake_case	)						->   int:
			return 0 if x < 0 else twenty_pence(x - 20	) + ten_pence(__snake_case	)


def 			_lowercase				(  __snake_case	)						->   int:
			return 0 if x < 0 else fifty_pence(x - 50	) + twenty_pence(__snake_case	)


def 			_lowercase				(  __snake_case	)						->   int:
			return 0 if x < 0 else one_pound(x - 100	) + fifty_pence(__snake_case	)


def 			_lowercase				(  __snake_case	)						->   int:
			return 0 if x < 0 else two_pound(x - 200	) + one_pound(__snake_case	)


def 			_lowercase				(  __snake_case = 200	)						->   int:
			return two_pound(__snake_case	)


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