






def 				A		(					)		-> int:
	return 1




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




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




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




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




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




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




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




def 				A		(					lowercase__  :  int = 200  )		-> int:
	return two_pound(lowercase__  )


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






import argparse
from argparse import Namespace

import torch
from torch import nn

from transformers import XGLMConfig, XGLMForCausalLM






def 		lowerCAmelCase  (	UpperCamelCase__   :   Union[str, Any]					)      ->    int:

						"""simple docstring"""





						__SCREAMING_SNAKE_CASE:				List[Any]           =   [
						    '''decoder.version''',
						    '''decoder.output_projection.weight''',
						    '''_float_tensor''',
						    '''decoder.embed_positions._float_tensor''',
						]
						for k in ignore_keys:
												state_dict.pop(UpperCamelCase__       ,			UpperCamelCase__					)






def 		lowerCAmelCase  (	UpperCamelCase__   :   str					)      ->    int:

						"""simple docstring"""





						__SCREAMING_SNAKE_CASE       ,__SCREAMING_SNAKE_CASE:				str           =   emb.weight.shape
						__SCREAMING_SNAKE_CASE:				List[str]           =   nn.Linear(UpperCamelCase__       ,			UpperCamelCase__       ,			bias=UpperCamelCase__					)
						__SCREAMING_SNAKE_CASE:				Tuple           =   emb.weight.data
						return lin_layer






def 		lowerCAmelCase  (	UpperCamelCase__   :   Optional[int]					)      ->    Optional[Any]:

						"""simple docstring"""





						__SCREAMING_SNAKE_CASE:				int           =   torch.load(UpperCamelCase__       ,			map_location='''cpu'''					)
						__SCREAMING_SNAKE_CASE:				Optional[int]           =   Namespace(**checkpoint['''cfg''']['''model''']					)
						__SCREAMING_SNAKE_CASE:				Union[str, Any]           =   checkpoint['''model''']
						remove_ignore_keys_(UpperCamelCase__					)
						__SCREAMING_SNAKE_CASE:				int           =   state_dict['''decoder.embed_tokens.weight'''].shape[0]

						__SCREAMING_SNAKE_CASE:				List[Any]           =   {key.replace('''decoder'''       ,			'''model'''					): val for key, val in state_dict.items()}

						__SCREAMING_SNAKE_CASE:				Dict           =   XGLMConfig(
						    vocab_size=UpperCamelCase__       ,			max_position_embeddings=args.max_target_positions       ,			num_layers=args.decoder_layers       ,			attention_heads=args.decoder_attention_heads       ,			ffn_dim=args.decoder_ffn_embed_dim       ,			d_model=args.decoder_embed_dim       ,			layerdrop=args.decoder_layerdrop       ,			dropout=args.dropout       ,			attention_dropout=args.attention_dropout       ,			activation_dropout=args.activation_dropout       ,			activation_function='''gelu'''       ,			scale_embedding=not args.no_scale_embedding       ,			tie_word_embeddings=args.share_decoder_input_output_embed       ,			)

						__SCREAMING_SNAKE_CASE:				int           =   XGLMForCausalLM(UpperCamelCase__					)
						__SCREAMING_SNAKE_CASE:				Optional[Any]           =   model.load_state_dict(UpperCamelCase__       ,			strict=UpperCamelCase__					)
						print(UpperCamelCase__					)
						__SCREAMING_SNAKE_CASE:				List[str]           =   make_linear_from_emb(model.model.embed_tokens					)

						return model


if __name__ == "__main__":
							lowerCAmelCase							:       Union[str, Any]					 =	argparse.ArgumentParser()
							# Required parameters
							parser.add_argument("""fairseq_path""", type=str, help="""path to a model.pt on local filesystem.""")
							parser.add_argument("""pytorch_dump_folder_path""", default=None, type=str, help="""Path to the output PyTorch model.""")
							lowerCAmelCase							:       List[str]					 =	parser.parse_args()
							lowerCAmelCase							:       Optional[int]					 =	convert_fairseq_xglm_checkpoint_from_disk(args.fairseq_path)
							model.save_pretrained(args.pytorch_dump_folder_path)



