

"""simple docstring"""




import torch
import torch.nn as nn
from transformers.modeling_utils import ModuleUtilsMixin
from transformers.models.ta.modeling_ta import TaBlock, TaConfig, TaLayerNorm

from ...configuration_utils import ConfigMixin, register_to_config
from ...models import ModelMixin


class 		_A       (			__SCREAMING_SNAKE_CASE				,       __SCREAMING_SNAKE_CASE				,       __SCREAMING_SNAKE_CASE					):





      @register_to_config
      def __init__(  self    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__ = False    ,						)   ->					Union[str, Any]:
         super().__init__()

         lowerCamelCase__						=			nn.Embedding(_a    ,						_a		)

         lowerCamelCase__						=			nn.Embedding(_a    ,						_a		)
         lowerCamelCase__						=			False

         lowerCamelCase__						=			nn.Dropout(p=_a		)

         lowerCamelCase__						=			TaConfig(
             vocab_size=_a    ,						d_model=_a    ,						num_heads=_a    ,						d_kv=_a    ,						d_ff=_a    ,						dropout_rate=_a    ,						feed_forward_proj=_a    ,						is_decoder=_a    ,						is_encoder_decoder=_a    ,						)

         lowerCamelCase__						=			nn.ModuleList()
         for lyr_num in range(_a		):
            lowerCamelCase__						=			TaBlock(_a		)
            self.encoders.append(_a		)

         lowerCamelCase__						=			TaLayerNorm(_a		)
         lowerCamelCase__						=			nn.Dropout(p=_a		)





      def 					_lowerCamelCase  (  self    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__		)   ->					List[str]:
         lowerCamelCase__						=			self.token_embedder(_a		)

         lowerCamelCase__						=			encoder_input_tokens.shape[1]
         lowerCamelCase__						=			torch.arange(_a    ,						device=encoder_input_tokens.device		)
         x += self.position_encoding(_a		)

         lowerCamelCase__						=			self.dropout_pre(_a		)

         # inverted the attention mask
         lowerCamelCase__						=			encoder_input_tokens.size()
         lowerCamelCase__						=			self.get_extended_attention_mask(_a    ,						_a		)

         for lyr in self.encoders:
            lowerCamelCase__						=			lyr(_a    ,						_a		)[0]
         lowerCamelCase__						=			self.layer_norm(_a		)

         return self.dropout_post(_a		), encoder_inputs_mask







"""simple docstring"""




def 	UpperCAmelCase__   (				)      ->      int:




   """simple docstring"""
   return 1



def 	UpperCAmelCase__   (				A__   )      ->      int:




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



def 	UpperCAmelCase__   (				A__   )      ->      int:




   """simple docstring"""
   return 0 if x < 0 else five_pence(x - 5   ) + two_pence(A__   )



def 	UpperCAmelCase__   (				A__   )      ->      int:




   """simple docstring"""
   return 0 if x < 0 else ten_pence(x - 10   ) + five_pence(A__   )



def 	UpperCAmelCase__   (				A__   )      ->      int:




   """simple docstring"""
   return 0 if x < 0 else twenty_pence(x - 20   ) + ten_pence(A__   )



def 	UpperCAmelCase__   (				A__   )      ->      int:




   """simple docstring"""
   return 0 if x < 0 else fifty_pence(x - 50   ) + twenty_pence(A__   )



def 	UpperCAmelCase__   (				A__   )      ->      int:




   """simple docstring"""
   return 0 if x < 0 else one_pound(x - 100   ) + fifty_pence(A__   )



def 	UpperCAmelCase__   (				A__   )      ->      int:




   """simple docstring"""
   return 0 if x < 0 else two_pound(x - 200   ) + one_pound(A__   )



def 	UpperCAmelCase__   (				A__ = 200   )      ->      int:




   """simple docstring"""
   return two_pound(A__   )


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




