




from typing import Dict, List, Optional, Union

import numpy as np

from .feature_extraction_utils import BatchFeature, FeatureExtractionMixin
from .utils import PaddingStrategy, TensorType, is_tf_tensor, is_torch_tensor, logging, to_numpy


lowerCamelCase							:						str					       =  logging.get_logger(__name__)







class     A(		UpperCamelCase  ):



 '''simple docstring'''


 def __init__(							self   :    str		,				A_   :    int		,				A_   :    int		,				A_   :    float		,				**A_   :    str    )  ->      Optional[Any]:

       """simple docstring"""






       lowerCamelCase_							=       feature_size
       lowerCamelCase_							=       sampling_rate
       lowerCamelCase_							=       padding_value

       lowerCamelCase_							=       kwargs.pop('padding_side'		,				'right'    )
       lowerCamelCase_							=       kwargs.pop('return_attention_mask'		,				A_    )

       super().__init__(**A_    )

 def 							a__					(							self   :    Tuple		,				A_   :    Union[
         BatchFeature,
         List[BatchFeature],
         Dict[str, BatchFeature],
         Dict[str, List[BatchFeature]],
         List[Dict[str, BatchFeature]],
     ]		,				A_   :    Union[bool, str, PaddingStrategy] = True		,				A_   :    Optional[int] = None		,				A_   :    bool = False		,				A_   :    Optional[int] = None		,				A_   :    Optional[bool] = None		,				A_   :    Optional[Union[str, TensorType]] = None		,				)  ->      BatchFeature:

       """simple docstring"""






       if isinstance(A_		,				(list, tuple)    ) and isinstance(processed_features[0]		,				(dict, BatchFeature)    ):
             lowerCamelCase_							=       {
                 key: [example[key] for example in processed_features] for key in processed_features[0].keys()
             }

       # The model's main input name, usually `input_values`, has be passed for padding
       if self.model_input_names[0] not in processed_features:
             raise ValueError(
                 'You should supply an instance of `transformers.BatchFeature` or list of `transformers.BatchFeature`'
                 f""" to this method that includes {self.model_input_names[0]}, but you provided"""
                 f""" {list(processed_features.keys()    )}"""    )

       lowerCamelCase_							=       processed_features[self.model_input_names[0]]
       lowerCamelCase_							=       (
           return_attention_mask if return_attention_mask is not None else self.return_attention_mask
       )

       if len(A_    ) == 0:
             if return_attention_mask:
                   lowerCamelCase_							=       []
             return processed_features

       # If we have PyTorch/TF tensors or lists as inputs, we cast them as Numpy arrays
       # and rebuild them afterwards if no return_tensors is specified
       # Note that we lose the specific device the tensor may be on for PyTorch

       lowerCamelCase_							=       required_input[0]
       if isinstance(A_		,				(list, tuple)    ):
             # first_element might be an empty list/tuple in some edge cases so we grab the first non empty element.
             lowerCamelCase_							=       0
             while len(required_input[index]    ) == 0:
                   index += 1
             if index < len(A_    ):
                   lowerCamelCase_							=       required_input[index][0]

       if return_tensors is None:
             if is_tf_tensor(A_    ):
                   lowerCamelCase_							=       'tf'
             elif is_torch_tensor(A_    ):
                   lowerCamelCase_							=       'pt'
             elif isinstance(A_		,				(int, float, list, tuple, np.ndarray)    ):
                   lowerCamelCase_							=       'np'
             else:
                   raise ValueError(
                       f"""type of {first_element} unknown: {type(A_    )}. """
                       'Should be one of a python, numpy, pytorch or tensorflow object.'    )

       for key, value in processed_features.items():
             if isinstance(value[0]		,				(int, float)    ):
                   lowerCamelCase_							=       to_numpy(A_    )
             else:
                   lowerCamelCase_							=       [to_numpy(A_    ) for v in value]

        # Convert padding_strategy in PaddingStrategy
       lowerCamelCase_							=       self._get_padding_strategies(padding=A_		,				max_length=A_    )

       lowerCamelCase_							=       processed_features[self.model_input_names[0]]

       lowerCamelCase_							=       len(A_    )
       if not all(len(A_    ) == batch_size for v in processed_features.values()    ):
             raise ValueError('Some items in the output dictionary have a different batch size than others.'    )

       lowerCamelCase_							=       []
       for i in range(A_    ):
             lowerCamelCase_							=       {k: v[i] for k, v in processed_features.items()}
             # truncation
             lowerCamelCase_							=       self._truncate(
                 A_		,				max_length=A_		,				pad_to_multiple_of=A_		,				truncation=A_		,				)
             truncated_inputs.append(A_    )

       if padding_strategy == PaddingStrategy.LONGEST:
             # make sure that `max_length` cannot be longer than the longest truncated length
             lowerCamelCase_							=       max(len(input_slice[self.model_input_names[0]]    ) for input_slice in truncated_inputs    )
             lowerCamelCase_							=       PaddingStrategy.MAX_LENGTH

       lowerCamelCase_							=       {}
       for i in range(A_    ):
             # padding
             lowerCamelCase_							=       self._pad(
                 truncated_inputs[i]		,				max_length=A_		,				padding_strategy=A_		,				pad_to_multiple_of=A_		,				return_attention_mask=A_		,				)

             for key, value in outputs.items():
                   if key not in batch_outputs:
                         lowerCamelCase_							=       []
                   if value.dtype is np.dtype(np.floataa    ):
                         lowerCamelCase_							=       value.astype(np.floataa    )
                   batch_outputs[key].append(A_    )

       return BatchFeature(A_		,				tensor_type=A_    )

 def 							a__					(							self   :    Any		,				A_   :    Union[Dict[str, np.ndarray], BatchFeature]		,				A_   :    Optional[int] = None		,				A_   :    PaddingStrategy = PaddingStrategy.DO_NOT_PAD		,				A_   :    Optional[int] = None		,				A_   :    Optional[bool] = None		,				)  ->      dict:

       """simple docstring"""






       lowerCamelCase_							=       processed_features[self.model_input_names[0]]

       if padding_strategy == PaddingStrategy.LONGEST:
             lowerCamelCase_							=       len(A_    )

       if max_length is not None and pad_to_multiple_of is not None and (max_length % pad_to_multiple_of != 0):
             lowerCamelCase_							=       ((max_length // pad_to_multiple_of) + 1) * pad_to_multiple_of

       lowerCamelCase_							=       padding_strategy != PaddingStrategy.DO_NOT_PAD and len(A_    ) < max_length

       if return_attention_mask and "attention_mask" not in processed_features:
             lowerCamelCase_							=       np.ones(len(A_    )		,				dtype=np.intaa    )

       if needs_to_be_padded:
             lowerCamelCase_							=       max_length - len(A_    )
             if self.padding_side == "right":
                   if return_attention_mask:
                         lowerCamelCase_							=       np.pad(
                             processed_features['attention_mask']		,				(0, difference)    )
                   lowerCamelCase_							=       ((0, difference), (0, 0)) if self.feature_size > 1 else (0, difference)
                   lowerCamelCase_							=       np.pad(
                       A_		,				A_		,				'constant'		,				constant_values=self.padding_value    )
             elif self.padding_side == "left":
                   if return_attention_mask:
                         lowerCamelCase_							=       np.pad(
                             processed_features['attention_mask']		,				(difference, 0)    )
                   lowerCamelCase_							=       ((difference, 0), (0, 0)) if self.feature_size > 1 else (difference, 0)
                   lowerCamelCase_							=       np.pad(
                       A_		,				A_		,				'constant'		,				constant_values=self.padding_value    )
             else:
                   raise ValueError('Invalid padding strategy:' + str(self.padding_side    )    )

       return processed_features

 def 							a__					(							self   :    Optional[Any]		,				A_   :    Union[Dict[str, np.ndarray], BatchFeature]		,				A_   :    Optional[int] = None		,				A_   :    Optional[int] = None		,				A_   :    Optional[bool] = None		,				)  ->      Any:

       """simple docstring"""






       if not truncation:
             return processed_features
       elif truncation and max_length is None:
             raise ValueError('When setting ``truncation=True``, make sure that ``max_length`` is defined.'    )

       lowerCamelCase_							=       processed_features[self.model_input_names[0]]

       # find `max_length` that fits `pad_to_multiple_of`
       if max_length is not None and pad_to_multiple_of is not None and (max_length % pad_to_multiple_of != 0):
             lowerCamelCase_							=       ((max_length // pad_to_multiple_of) + 1) * pad_to_multiple_of

       lowerCamelCase_							=       len(A_    ) > max_length

       if needs_to_be_truncated:
             lowerCamelCase_							=       processed_features[self.model_input_names[0]][:max_length]
             if "attention_mask" in processed_features:
                   lowerCamelCase_							=       processed_features['attention_mask'][:max_length]

       return processed_features





 def 							a__					(							self   :    Optional[Any]		,				A_   :    Optional[int]=False		,				A_   :    Any=None    )  ->      Optional[Any]:

       """simple docstring"""






       if padding is not False:
             if padding is True:
                   lowerCamelCase_							=       PaddingStrategy.LONGEST  # Default to pad to the longest sequence in the batch
             elif not isinstance(A_		,				A_    ):
                   lowerCamelCase_							=       PaddingStrategy(A_    )
             elif isinstance(A_		,				A_    ):
                   lowerCamelCase_							=       padding
       else:
             lowerCamelCase_							=       PaddingStrategy.DO_NOT_PAD

       # Set max length if needed
       if max_length is None:
             if padding_strategy == PaddingStrategy.MAX_LENGTH:
                   raise ValueError(
                       f"""When setting ``padding={PaddingStrategy.MAX_LENGTH}``, make sure that max_length is defined"""    )

        # Test if we have a padding value
       if padding_strategy != PaddingStrategy.DO_NOT_PAD and (self.padding_value is None):
             raise ValueError(
                 'Asking to pad but the feature_extractor does not have a padding value. Please select a value to use'
                 ' as `padding_value`. For example: `feature_extractor.padding_value = 0.0`.'    )

       return padding_strategy









"""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())))



