


def 			lowerCAmelCase (		)-> int:
				return 1



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



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



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



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



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



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



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



def 			lowerCAmelCase (		lowerCAmelCase_ = 200 )-> int:
				return two_pound(lowerCAmelCase_ )


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



# We ignore warnings about stepping the scheduler since we step it ourselves during gradient accumulation

import warnings

from .state import AcceleratorState, GradientState


warnings.filterwarnings("""ignore""", category=UserWarning, module="""torch.optim.lr_scheduler""")







class 				snake_case__:







						'''simple docstring'''




						def __init__(				self   ,						__lowercase   ,						__lowercase   ,						__lowercase = True   ,						__lowercase = False							)					->    Tuple:
										lowerCAmelCase_ :      Optional[int]    				=				scheduler
										lowerCAmelCase_ :      Dict    				=				optimizers if isinstance(__lowercase   ,						(list, tuple)							) else [optimizers]
										lowerCAmelCase_ :      str    				=				split_batches
										lowerCAmelCase_ :      Any    				=				step_with_optimizer
										lowerCAmelCase_ :      Optional[Any]    				=				GradientState()




						def 						lowercase_ (				self   ,						*__lowercase   ,						**__lowercase							)					->    Any:
										if not self.step_with_optimizer:
														# No link between scheduler and optimizer -> just step
														self.scheduler.step(*__lowercase   ,						**__lowercase							)
														return

										# Otherwise, first make sure the optimizer was stepped.
										if not self.gradient_state.sync_gradients:
														if self.gradient_state.adjust_scheduler:
																		self.scheduler._step_count += 1
														return

										for opt in self.optimizers:
														if opt.step_was_skipped:
																		return
										if self.split_batches:
														# Split batches -> the training dataloader batch size is not changed so one step per training step
														self.scheduler.step(*__lowercase   ,						**__lowercase							)
										else:
														# Otherwise the training dataloader batch size was multiplied by `num_processes`, so we need to do
														# num_processes steps per training step
														lowerCAmelCase_ :      Optional[Any]    				=				AcceleratorState().num_processes
														for _ in range(__lowercase							):
																		# Special case when using OneCycle and `drop_last` was not used
																		if hasattr(self.scheduler   ,						'''total_steps'''							):
																						if self.scheduler._step_count <= self.scheduler.total_steps:
																										self.scheduler.step(*__lowercase   ,						**__lowercase							)
																		else:
																						self.scheduler.step(*__lowercase   ,						**__lowercase							)




						def 						lowercase_ (				self							)					->    Union[str, Any]:
										return self.scheduler.get_last_lr()




						def 						lowercase_ (				self							)					->    List[str]:
										return self.scheduler.state_dict()




						def 						lowercase_ (				self   ,						__lowercase							)					->    int:
										self.scheduler.load_state_dict(__lowercase							)




						def 						lowercase_ (				self							)					->    Tuple:
										return self.scheduler.get_lr()




						def 						lowercase_ (				self   ,						*__lowercase   ,						**__lowercase							)					->    int:
										return self.scheduler.print_lr(*__lowercase   ,						**__lowercase							)