


"""simple docstring"""


from pickle import UnpicklingError

import jax
import jax.numpy as jnp
import numpy as np
from flax.serialization import from_bytes
from flax.traverse_util import flatten_dict

from ..utils import logging


UpperCamelCase						:				Optional[int]             =      logging.get_logger(__name__)







def  __snake_case       (   UpperCamelCase__ ,			UpperCamelCase__	)      ->		Tuple:







		"""simple docstring"""





		try:
				with open(UpperCamelCase__ ,			'rb'	) as flax_state_f:
						A					       = from_bytes(UpperCamelCase__ ,			flax_state_f.read()	)
		except UnpicklingError as e:
				try:
						with open(UpperCamelCase__	) as f:
								if f.read().startswith('version'	):
										raise OSError(
										    'You seem to have cloned a repository without having git-lfs installed. Please'
										    ' install git-lfs and run `git lfs install` followed by `git lfs pull` in the'
										    ' folder you cloned.'	)
								else:
										raise ValueError from e
				except (UnicodeDecodeError, ValueError):
						raise EnvironmentError(f'Unable to convert {model_file} to Flax deserializable object. '	)

		return load_flax_weights_in_pytorch_model(UpperCamelCase__ ,			UpperCamelCase__	)







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







		"""simple docstring"""





		try:
				import torch  # noqa: F401
		except ImportError:
				logger.error(
				    'Loading Flax weights in PyTorch requires both PyTorch and Flax to be installed. Please see'
				    ' https://pytorch.org/ and https://flax.readthedocs.io/en/latest/installation.html for installation'
				    ' instructions.'	)
				raise

		# check if we have bf16 weights
		A					       = flatten_dict(jax.tree_util.tree_map(lambda UpperCamelCase__	: x.dtype == jnp.bfloataa ,			UpperCamelCase__	)	).values()
		if any(UpperCamelCase__	):
				# convert all weights to fp32 if they are bf16 since torch.from_numpy can-not handle bf16

				# and bf16 is not fully supported in PT yet.
				logger.warning(
				    'Found ``bfloat16`` weights in Flax model. Casting all ``bfloat16`` weights to ``float32`` '
				    'before loading those in PyTorch model.'	)
				A					       = jax.tree_util.tree_map(
				    lambda UpperCamelCase__	: params.astype(np.floataa	) if params.dtype == jnp.bfloataa else params ,			UpperCamelCase__	)

		A					       = ''

		A					       = flatten_dict(UpperCamelCase__ ,			sep='.'	)
		A					       = pt_model.state_dict()

		# keep track of unexpected & missing keys
		A					       = []
		A					       = set(pt_model_dict.keys()	)

		for flax_key_tuple, flax_tensor in flax_state_dict.items():
				A					       = flax_key_tuple.split('.'	)

				if flax_key_tuple_array[-1] == "kernel" and flax_tensor.ndim == 4:
						A					       = flax_key_tuple_array[:-1] + ['weight']
						A					       = jnp.transpose(UpperCamelCase__ ,			(3, 2, 0, 1)	)
				elif flax_key_tuple_array[-1] == "kernel":
						A					       = flax_key_tuple_array[:-1] + ['weight']
						A					       = flax_tensor.T
				elif flax_key_tuple_array[-1] == "scale":
						A					       = flax_key_tuple_array[:-1] + ['weight']

				if "time_embedding" not in flax_key_tuple_array:
						for i, flax_key_tuple_string in enumerate(UpperCamelCase__	):
								A					       = (
								    flax_key_tuple_string.replace('_0' ,			'.0'	)
								    .replace('_1' ,			'.1'	)
								    .replace('_2' ,			'.2'	)
								    .replace('_3' ,			'.3'	)
								    .replace('_4' ,			'.4'	)
								    .replace('_5' ,			'.5'	)
								    .replace('_6' ,			'.6'	)
								    .replace('_7' ,			'.7'	)
								    .replace('_8' ,			'.8'	)
								    .replace('_9' ,			'.9'	)
								)

				A					       = '.'.join(UpperCamelCase__	)

				if flax_key in pt_model_dict:
						if flax_tensor.shape != pt_model_dict[flax_key].shape:
								raise ValueError(
								    f'Flax checkpoint seems to be incorrect. Weight {flax_key_tuple} was expected '
								    f'to be of shape {pt_model_dict[flax_key].shape}, but is {flax_tensor.shape}.'	)
						else:
								# add weight to pytorch dict
								A					       = np.asarray(UpperCamelCase__	) if not isinstance(UpperCamelCase__ ,			np.ndarray	) else flax_tensor
								A					       = torch.from_numpy(UpperCamelCase__	)
								# remove from missing keys
								missing_keys.remove(UpperCamelCase__	)
				else:
						# weight is not expected by PyTorch model
						unexpected_keys.append(UpperCamelCase__	)

		pt_model.load_state_dict(UpperCamelCase__	)

		# re-transform missing_keys to list
		A					       = list(UpperCamelCase__	)

		if len(UpperCamelCase__	) > 0:
				logger.warning(
				    'Some weights of the Flax model were not used when initializing the PyTorch model'
				    f' {pt_model.__class__.__name__}: {unexpected_keys}\n- This IS expected if you are initializing'
				    f' {pt_model.__class__.__name__} from a Flax model trained on another task or with another architecture'
				    ' (e.g. initializing a BertForSequenceClassification model from a FlaxBertForPreTraining model).\n- This'
				    f' IS NOT expected if you are initializing {pt_model.__class__.__name__} from a Flax model that you expect'
				    ' to be exactly identical (e.g. initializing a BertForSequenceClassification model from a'
				    ' FlaxBertForSequenceClassification model).'	)
		if len(UpperCamelCase__	) > 0:
				logger.warning(
				    f'Some weights of {pt_model.__class__.__name__} were not initialized from the Flax model and are newly'
				    f' initialized: {missing_keys}\nYou should probably TRAIN this model on a down-stream task to be able to'
				    ' use it for predictions and inference.'	)

		return pt_model









"""simple docstring"""


def  __snake_case       (   )      ->		int:







		"""simple docstring"""





		return 1







def  __snake_case       (   UpperCamelCase__	)      ->		int:







		"""simple docstring"""





		return 0 if x < 0 else two_pence(x - 2	) + one_pence()







def  __snake_case       (   UpperCamelCase__	)      ->		int:







		"""simple docstring"""





		return 0 if x < 0 else five_pence(x - 5	) + two_pence(UpperCamelCase__	)







def  __snake_case       (   UpperCamelCase__	)      ->		int:







		"""simple docstring"""





		return 0 if x < 0 else ten_pence(x - 10	) + five_pence(UpperCamelCase__	)







def  __snake_case       (   UpperCamelCase__	)      ->		int:







		"""simple docstring"""





		return 0 if x < 0 else twenty_pence(x - 20	) + ten_pence(UpperCamelCase__	)







def  __snake_case       (   UpperCamelCase__	)      ->		int:







		"""simple docstring"""





		return 0 if x < 0 else fifty_pence(x - 50	) + twenty_pence(UpperCamelCase__	)







def  __snake_case       (   UpperCamelCase__	)      ->		int:







		"""simple docstring"""





		return 0 if x < 0 else one_pound(x - 100	) + fifty_pence(UpperCamelCase__	)







def  __snake_case       (   UpperCamelCase__	)      ->		int:







		"""simple docstring"""





		return 0 if x < 0 else two_pound(x - 200	) + one_pound(UpperCamelCase__	)







def  __snake_case       (   UpperCamelCase__ = 200	)      ->		int:







		"""simple docstring"""





		return two_pound(UpperCamelCase__	)


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





