





from collections import OrderedDict
from typing import Any, Mapping, Optional

from ... import PreTrainedTokenizer
from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig, OnnxSeqaSeqConfigWithPast
from ...onnx.utils import compute_effective_axis_dimension
from ...utils import TensorType, is_torch_available, logging


_UpperCamelCase   :							Any     =	logging.get_logger(__name__)

_UpperCamelCase   :							int     =	{
    """facebook/m2m100_418M""": """https://huggingface.co/facebook/m2m100_418M/resolve/main/config.json""",
    # See all M2M100 models at https://huggingface.co/models?filter=m2m_100
}







class 						_lowerCAmelCase(						lowerCamelCase__):

  """simple docstring"""







  lowerCamelCase__      					=   'm2m_100'
  lowerCamelCase__      					=   ['past_key_values']
  lowerCamelCase__      					=   {'num_attention_heads': 'encoder_attention_heads', 'hidden_size': 'd_model'}

  def __init__( self  ,    UpperCAmelCase=12_81_12  ,    UpperCAmelCase=10_24  ,    UpperCAmelCase=12  ,    UpperCAmelCase=40_96  ,    UpperCAmelCase=16  ,    UpperCAmelCase=12  ,    UpperCAmelCase=40_96  ,    UpperCAmelCase=16  ,    UpperCAmelCase=0.05  ,    UpperCAmelCase=0.05  ,    UpperCAmelCase=True  ,    UpperCAmelCase=True  ,    UpperCAmelCase="relu"  ,    UpperCAmelCase=10_24  ,    UpperCAmelCase=0.1  ,    UpperCAmelCase=0.1  ,    UpperCAmelCase=0.0  ,    UpperCAmelCase=0.02  ,    UpperCAmelCase=2  ,    UpperCAmelCase=True  ,    UpperCAmelCase=1  ,    UpperCAmelCase=0  ,    UpperCAmelCase=2  ,    **UpperCAmelCase  ,    )-> Dict:
     __A				 =       vocab_size
     __A				 =       max_position_embeddings
     __A				 =       d_model
     __A				 =       encoder_ffn_dim
     __A				 =       encoder_layers
     __A				 =       encoder_attention_heads
     __A				 =       decoder_ffn_dim
     __A				 =       decoder_layers
     __A				 =       decoder_attention_heads
     __A				 =       dropout
     __A				 =       attention_dropout
     __A				 =       activation_dropout
     __A				 =       activation_function
     __A				 =       init_std
     __A				 =       encoder_layerdrop
     __A				 =       decoder_layerdrop
     __A				 =       use_cache
     __A				 =       encoder_layers
     __A				 =       scale_embedding  # scale factor will be sqrt(d_model) if True

     super().__init__(
         pad_token_id=lowercase_  ,    bos_token_id=lowercase_  ,    eos_token_id=lowercase_  ,    is_encoder_decoder=lowercase_  ,    decoder_start_token_id=lowercase_  ,    **lowercase_  ,    )







class 						_lowerCAmelCase(						lowerCamelCase__):

  """simple docstring"""







  @property
  def 		SCREAMING_SNAKE_CASE__	( self     )-> Mapping[str, Mapping[int, str]]:
     __A				 =       OrderedDict(
         [
             ('''input_ids''', {0: '''batch''', 1: '''encoder_sequence'''}),
             ('''attention_mask''', {0: '''batch''', 1: '''encoder_sequence'''}),
         ]     )

     if self.use_past:
        __A				 =       {0: '''batch'''}
        __A				 =       {0: '''batch''', 1: '''past_decoder_sequence + sequence'''}
     else:
        __A				 =       {0: '''batch''', 1: '''decoder_sequence'''}
        __A				 =       {0: '''batch''', 1: '''decoder_sequence'''}

     if self.use_past:
        self.fill_with_past_key_values_(lowercase_  ,    direction='''inputs'''     )
     return common_inputs

  def 		SCREAMING_SNAKE_CASE__	( self  ,    UpperCAmelCase  ,    UpperCAmelCase = -1  ,    UpperCAmelCase = -1  ,    UpperCAmelCase = False  ,    UpperCAmelCase = None  ,    )-> Mapping[str, Any]:
     __A				 =       compute_effective_axis_dimension(
         lowercase_  ,    fixed_dimension=OnnxConfig.default_fixed_batch  ,    num_token_to_add=0     )

     # If dynamic axis (-1) we forward with a fixed dimension of 8 tokens to avoid optimizations made by ONNX
     __A				 =       tokenizer.num_special_tokens_to_add(lowercase_     )
     __A				 =       compute_effective_axis_dimension(
         lowercase_  ,    fixed_dimension=OnnxConfig.default_fixed_sequence  ,    num_token_to_add=lowercase_     )

     # Generate dummy inputs according to compute batch and sequence
     __A				 =       [''' '''.join([tokenizer.unk_token]     ) * seq_length] * batch_size
     __A				 =       dict(tokenizer(lowercase_  ,    return_tensors=lowercase_     )     )
     return common_inputs

  def 		SCREAMING_SNAKE_CASE__	( self  ,    UpperCAmelCase  ,    UpperCAmelCase = -1  ,    UpperCAmelCase = -1  ,    UpperCAmelCase = False  ,    UpperCAmelCase = None  ,    )-> Mapping[str, Any]:
     __A				 =       self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
         lowercase_  ,    lowercase_  ,    lowercase_  ,    lowercase_  ,    lowercase_     )

     # Generate decoder inputs
     __A				 =       seq_length if not self.use_past else 1
     __A				 =       self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
         lowercase_  ,    lowercase_  ,    lowercase_  ,    lowercase_  ,    lowercase_     )
     __A				 =       {f"decoder_{name}": tensor for name, tensor in decoder_inputs.items()}
     __A				 =       dict(**lowercase_  ,    **lowercase_     )

     if self.use_past:
        if not is_torch_available():
           raise ValueError('''Cannot generate dummy past_keys inputs without PyTorch installed.'''     )
        else:
           import torch
        __A ,						__A				 =       common_inputs['''input_ids'''].shape
        __A				 =       common_inputs['''decoder_input_ids'''].shape[1]
        __A ,						__A				 =       self.num_attention_heads
        __A				 =       (
            batch,
            num_encoder_attention_heads,
            encoder_seq_length,
            self._config.hidden_size // num_encoder_attention_heads,
        )
        __A				 =       decoder_seq_length + 3
        __A				 =       (
            batch,
            num_decoder_attention_heads,
            decoder_past_length,
            self._config.hidden_size // num_decoder_attention_heads,
        )

        __A				 =       torch.cat(
            [common_inputs['''decoder_attention_mask'''], torch.ones(lowercase_  ,    lowercase_     )]  ,    dim=1     )

        __A				 =       []
        # If the number of encoder and decoder layers are present in the model configuration, both are considered
        __A ,						__A				 =       self.num_layers
        __A				 =       min(lowercase_  ,    lowercase_     )
        __A				 =       max(lowercase_  ,    lowercase_     ) - min_num_layers
        __A				 =       '''encoder''' if num_encoder_layers > num_decoder_layers else '''decoder'''

        for _ in range(lowercase_     ):
           common_inputs["past_key_values"].append(
               (
                   torch.zeros(lowercase_     ),
                   torch.zeros(lowercase_     ),
                   torch.zeros(lowercase_     ),
                   torch.zeros(lowercase_     ),
               )     )
        # TODO: test this.
        __A				 =       encoder_shape if remaining_side_name == '''encoder''' else decoder_shape
        for _ in range(lowercase_  ,    lowercase_     ):
           common_inputs["past_key_values"].append((torch.zeros(lowercase_     ), torch.zeros(lowercase_     ))     )
     return common_inputs





  lowerCamelCase__      					=   _generate_dummy_inputs_for_default_and_seqaseq_lm








def 				__UpperCamelCase  (		snake_case = 1_0_0     )  ->						int:


   '''simple docstring'''







   __A				 =       [[0 for _ in range(snake_case     )] for _ in range(m + 1     )]
   for i in range(m + 1     ):
      __A				 =       1

   for n in range(m + 1     ):
      for k in range(1    ,	snake_case     ):
         memo[n][k] += memo[n][k - 1]
         if n > k:
            memo[n][k] += memo[n - k - 1][k]

   return memo[m][m - 1] - 1


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

