






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


A        =			logging.get_logger(__name__)



def 					_lowerCamelCase(			lowerCAmelCase__				:		Optional[int]    ,    lowerCAmelCase__				:		List[str]      ):





				'''simple docstring'''







				try:
								with open(snake_case__    ,    'rb'      ) as flax_state_f:
												SCREAMING_SNAKE_CASE_   :	int													=   from_bytes(snake_case__    ,    flax_state_f.read()      )
				except UnpicklingError as e:
								try:
												with open(snake_case__      ) 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(snake_case__    ,    snake_case__      )



def 					_lowerCamelCase(			lowerCAmelCase__				:		Dict    ,    lowerCAmelCase__				:		List[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
				SCREAMING_SNAKE_CASE_   :	List[Any]													=   flatten_dict(jax.tree_util.tree_map(lambda lowerCAmelCase__      : x.dtype == jnp.bfloataa    ,    snake_case__      )      ).values()
				if any(snake_case__      ):
								# 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.'      )
								SCREAMING_SNAKE_CASE_   :	Tuple													=   jax.tree_util.tree_map(
								    lambda lowerCAmelCase__      : params.astype(np.floataa      ) if params.dtype == jnp.bfloataa else params    ,    snake_case__      )

				SCREAMING_SNAKE_CASE_   :	Optional[int]													=   """"""

				SCREAMING_SNAKE_CASE_   :	Dict													=   flatten_dict(snake_case__    ,    sep='.'      )
				SCREAMING_SNAKE_CASE_   :	int													=   pt_model.state_dict()

				# keep track of unexpected & missing keys
				SCREAMING_SNAKE_CASE_   :	Optional[Any]													=   []
				SCREAMING_SNAKE_CASE_   :	str													=   set(pt_model_dict.keys()      )

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

								if flax_key_tuple_array[-1] == "kernel" and flax_tensor.ndim == 4:
												SCREAMING_SNAKE_CASE_   :	str													=   flax_key_tuple_array[:-1] + ["""weight"""]
												SCREAMING_SNAKE_CASE_   :	str													=   jnp.transpose(snake_case__    ,    (3, 2, 0, 1)      )
								elif flax_key_tuple_array[-1] == "kernel":
												SCREAMING_SNAKE_CASE_   :	List[str]													=   flax_key_tuple_array[:-1] + ["""weight"""]
												SCREAMING_SNAKE_CASE_   :	str													=   flax_tensor.T
								elif flax_key_tuple_array[-1] == "scale":
												SCREAMING_SNAKE_CASE_   :	Union[str, Any]													=   flax_key_tuple_array[:-1] + ["""weight"""]

								if "time_embedding" not in flax_key_tuple_array:
												for i, flax_key_tuple_string in enumerate(snake_case__      ):
																SCREAMING_SNAKE_CASE_   :	str													=   (
																    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'      )
																)

								SCREAMING_SNAKE_CASE_   :	Dict													=   """.""".join(snake_case__      )

								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
																SCREAMING_SNAKE_CASE_   :	Optional[Any]													=   np.asarray(snake_case__      ) if not isinstance(snake_case__    ,    np.ndarray      ) else flax_tensor
																SCREAMING_SNAKE_CASE_   :	Optional[Any]													=   torch.from_numpy(snake_case__      )
																# remove from missing keys
																missing_keys.remove(snake_case__      )
								else:
												# weight is not expected by PyTorch model
												unexpected_keys.append(snake_case__      )

				pt_model.load_state_dict(snake_case__      )

				# re-transform missing_keys to list
				SCREAMING_SNAKE_CASE_   :	Tuple													=   list(snake_case__      )

				if len(snake_case__      ) > 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(snake_case__      ) > 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







def 					_lowerCamelCase(			):





				'''simple docstring'''







				return 1



def 					_lowerCamelCase(			lowerCAmelCase__				:		int      ):





				'''simple docstring'''







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



def 					_lowerCamelCase(			lowerCAmelCase__				:		int      ):





				'''simple docstring'''







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



def 					_lowerCamelCase(			lowerCAmelCase__				:		int      ):





				'''simple docstring'''







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



def 					_lowerCamelCase(			lowerCAmelCase__				:		int      ):





				'''simple docstring'''







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



def 					_lowerCamelCase(			lowerCAmelCase__				:		int      ):





				'''simple docstring'''







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



def 					_lowerCamelCase(			lowerCAmelCase__				:		int      ):





				'''simple docstring'''







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



def 					_lowerCamelCase(			lowerCAmelCase__				:		int      ):





				'''simple docstring'''







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



def 					_lowerCamelCase(			lowerCAmelCase__				:		int = 200      ):





				'''simple docstring'''







				return two_pound(lowerCAmelCase__      )


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