




"""simple docstring"""







import inspect
import os
import unittest
from dataclasses import dataclass

import torch

from accelerate import Accelerator, DistributedDataParallelKwargs, GradScalerKwargs
from accelerate.state import AcceleratorState
from accelerate.test_utils import execute_subprocess_async, require_cuda, require_multi_gpu
from accelerate.utils import KwargsHandler




@dataclass
class    lowerCAmelCase__							(      UpperCAmelCase__     ):


				"""simple docstring"""





				__UpperCAmelCase			:  List[Any]			   =   0
				__UpperCAmelCase			:  Optional[int]			   =   False
				__UpperCAmelCase			:  Tuple			   =   3.0





class    lowerCAmelCase__							(      unittest.TestCase     ):


				"""simple docstring"""





				def    snake_case     (  self       :						int    ):
						self.assertDictEqual(MockClass().to_kwargs()     , {}    )
						self.assertDictEqual(MockClass(a=2    ).to_kwargs()     , {"a": 2}    )
						self.assertDictEqual(MockClass(a=2     , b=_a    ).to_kwargs()     , {"a": 2, "b": True}    )
						self.assertDictEqual(MockClass(a=2     , c=2.2_5    ).to_kwargs()     , {"a": 2, "c": 2.2_5}    )



				@require_cuda
				def    snake_case     (  self       :						Dict    ):
						__lowercase					:		Any        =					GradScalerKwargs(init_scale=1_0_2_4     , growth_factor=2    )
						AcceleratorState._reset_state()
						__lowercase					:		int        =					Accelerator(mixed_precision="fp16"     , kwargs_handlers=[scaler_handler]    )
						print(accelerator.use_fpaa    )
						__lowercase					:		Union[str, Any]        =					accelerator.scaler

						# Check the kwargs have been applied
						self.assertEqual(scaler._init_scale     , 1_0_2_4.0    )
						self.assertEqual(scaler._growth_factor     , 2.0    )

						# Check the other values are at the default
						self.assertEqual(scaler._backoff_factor     , 0.5    )
						self.assertEqual(scaler._growth_interval     , 2_0_0_0    )
						self.assertEqual(scaler._enabled     , _a    )



				@require_multi_gpu
				def    snake_case     (  self       :						Optional[int]    ):
						__lowercase					:		str        =					["torchrun", f'--nproc_per_node={torch.cuda.device_count()}', inspect.getfile(self.__class__    )]
						execute_subprocess_async(_a     , env=os.environ.copy()    )


if __name__ == "__main__":
						__A :	Optional[Any]       =   DistributedDataParallelKwargs(bucket_cap_mb=1_5, find_unused_parameters=True)
						__A :	Tuple       =   Accelerator(kwargs_handlers=[ddp_scaler])
						__A :	List[str]       =   torch.nn.Linear(1_0_0, 2_0_0)
						__A :	Union[str, Any]       =   accelerator.prepare(model)

						# Check the values changed in kwargs
						__A :	List[Any]       =   """"""
						__A :	List[Any]       =   model.bucket_bytes_cap // (1_0_2_4 * 1_0_2_4)
						if observed_bucket_cap_map != 1_5:
												error_msg += F"Kwargs badly passed, should have `15` but found {observed_bucket_cap_map}.\n"
						if model.find_unused_parameters is not True:
												error_msg += F"Kwargs badly passed, should have `True` but found {model.find_unused_parameters}.\n"

						# Check the values of the defaults
						if model.dim != 0:
												error_msg += F"Default value not respected, should have `0` but found {model.dim}.\n"
						if model.broadcast_buffers is not True:
												error_msg += F"Default value not respected, should have `True` but found {model.broadcast_buffers}.\n"
						if model.gradient_as_bucket_view is not False:
												error_msg += F"Default value not respected, should have `False` but found {model.gradient_as_bucket_view}.\n"

						# Raise error at the end to make sure we don't stop at the first failure.
						if len(error_msg) > 0:
												raise ValueError(error_msg)






"""simple docstring"""




def        a__					(							)		->   int:
			return 1



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



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



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



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



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



def        a__					(							snake_case__							)		->   int:
			return 0 if x < 0 else one_pound(x - 1_00							) + fifty_pence(snake_case__							)



def        a__					(							snake_case__							)		->   int:
			return 0 if x < 0 else two_pound(x - 2_00							) + one_pound(snake_case__							)



def        a__					(							snake_case__ = 2_00							)		->   int:
			return two_pound(snake_case__							)


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



