


import unittest

from transformers import is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
       import torch

       from transformers import (
           RemBertConfig,
           RemBertForCausalLM,
           RemBertForMaskedLM,
           RemBertForMultipleChoice,
           RemBertForQuestionAnswering,
           RemBertForSequenceClassification,
           RemBertForTokenClassification,
           RemBertModel,
       )
       from transformers.models.rembert.modeling_rembert import REMBERT_PRETRAINED_MODEL_ARCHIVE_LIST


class        A_					:




      '''simple docstring'''


      def __init__(				self:       int						,      a:       List[str]						,      a:       List[str]=13						,      a:       Dict=7						,      a:       Union[str, Any]=True						,      a:       Tuple=True						,      a:       Optional[Any]=True						,      a:       Union[str, Any]=True						,      a:       str=99						,      a:       List[Any]=32						,      a:       Dict=18						,      a:       List[Any]=43						,      a:       Tuple=5						,      a:       str=4						,      a:       Any=37						,      a:       int="gelu"						,      a:       List[Any]=0.1						,      a:       int=0.1						,      a:       Tuple=512						,      a:       Union[str, Any]=16						,      a:       Union[str, Any]=2						,      a:       Tuple=0.0_2						,      a:       Any=3						,      a:       str=4						,      a:       str=None						,      ):
       __lowerCamelCase		:							int							=						parent
       __lowerCamelCase		:							str							=						batch_size
       __lowerCamelCase		:							int							=						seq_length
       __lowerCamelCase		:							int							=						is_training
       __lowerCamelCase		:							Any							=						use_input_mask
       __lowerCamelCase		:							List[Any]							=						use_token_type_ids
       __lowerCamelCase		:							Any							=						use_labels
       __lowerCamelCase		:							str							=						vocab_size
       __lowerCamelCase		:							int							=						hidden_size
       __lowerCamelCase		:							List[str]							=						input_embedding_size
       __lowerCamelCase		:							Any							=						output_embedding_size
       __lowerCamelCase		:							Tuple							=						num_hidden_layers
       __lowerCamelCase		:							Optional[Any]							=						num_attention_heads
       __lowerCamelCase		:							List[Any]							=						intermediate_size
       __lowerCamelCase		:							List[Any]							=						hidden_act
       __lowerCamelCase		:							Tuple							=						hidden_dropout_prob
       __lowerCamelCase		:							Optional[int]							=						attention_probs_dropout_prob
       __lowerCamelCase		:							List[str]							=						max_position_embeddings
       __lowerCamelCase		:							str							=						type_vocab_size
       __lowerCamelCase		:							int							=						type_sequence_label_size
       __lowerCamelCase		:							Tuple							=						initializer_range
       __lowerCamelCase		:							Dict							=						num_labels
       __lowerCamelCase		:							Any							=						num_choices
       __lowerCamelCase		:							Optional[int]							=						scope




      def      _snake_case	(				self:       Dict				):
       __lowerCamelCase		:							Any							=						ids_tensor([self.batch_size, self.seq_length]						,      self.vocab_size				)

       __lowerCamelCase		:							Dict							=						None
       if self.use_input_mask:
        __lowerCamelCase		:							str							=						random_attention_mask([self.batch_size, self.seq_length]				)

       __lowerCamelCase		:							Dict							=						None
       if self.use_token_type_ids:
        __lowerCamelCase		:							Optional[Any]							=						ids_tensor([self.batch_size, self.seq_length]						,      self.type_vocab_size				)

       __lowerCamelCase		:							str							=						None
       __lowerCamelCase		:							Optional[Any]							=						None
       __lowerCamelCase		:							Optional[int]							=						None
       if self.use_labels:
        __lowerCamelCase		:							str							=						ids_tensor([self.batch_size]						,      self.type_sequence_label_size				)
        __lowerCamelCase		:							Any							=						ids_tensor([self.batch_size, self.seq_length]						,      self.num_labels				)
        __lowerCamelCase		:							Tuple							=						ids_tensor([self.batch_size]						,      self.num_choices				)

       __lowerCamelCase		:							Optional[int]							=						RemBertConfig(
           vocab_size=self.vocab_size						,      hidden_size=self.hidden_size						,      input_embedding_size=self.input_embedding_size						,      output_embedding_size=self.output_embedding_size						,      num_hidden_layers=self.num_hidden_layers						,      num_attention_heads=self.num_attention_heads						,      intermediate_size=self.intermediate_size						,      hidden_act=self.hidden_act						,      hidden_dropout_prob=self.hidden_dropout_prob						,      attention_probs_dropout_prob=self.attention_probs_dropout_prob						,      max_position_embeddings=self.max_position_embeddings						,      type_vocab_size=self.type_vocab_size						,      is_decoder=a						,      initializer_range=self.initializer_range						,      )

       return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels




      def      _snake_case	(				self:       Tuple				):
       (
           (
           __lowerCamelCase
       )					,     (
           __lowerCamelCase
       )					,     (
           __lowerCamelCase
       )					,     (
           __lowerCamelCase
       )					,     (
           __lowerCamelCase
       )					,     (
           __lowerCamelCase
       )					,     (
           __lowerCamelCase
       )					,     
       )		:							Dict							=						self.prepare_config_and_inputs()

       __lowerCamelCase		:							Optional[int]							=						True
       __lowerCamelCase		:							str							=						floats_tensor([self.batch_size, self.seq_length, self.hidden_size]				)
       __lowerCamelCase		:							Union[str, Any]							=						ids_tensor([self.batch_size, self.seq_length]						,      vocab_size=2				)

       return (
           config,
           input_ids,
           token_type_ids,
           input_mask,
           sequence_labels,
           token_labels,
           choice_labels,
           encoder_hidden_states,
           encoder_attention_mask,
       )




      def      _snake_case	(				self:       List[str]						,      a:       List[str]						,      a:       Dict						,      a:       List[Any]						,      a:       Dict						,      a:       Optional[Any]						,      a:       Dict						,      a:       List[str]				):
       __lowerCamelCase		:							Optional[int]							=						RemBertModel(config=a				)
       model.to(a				)
       model.eval()
       __lowerCamelCase		:							Tuple							=						model(a						,      attention_mask=a						,      token_type_ids=a				)
       __lowerCamelCase		:							Optional[Any]							=						model(a						,      token_type_ids=a				)
       __lowerCamelCase		:							str							=						model(a				)
       self.parent.assertEqual(result.last_hidden_state.shape						,      (self.batch_size, self.seq_length, self.hidden_size)				)




      def      _snake_case	(				self:       Union[str, Any]						,      a:       Optional[int]						,      a:       List[Any]						,      a:       str						,      a:       Any						,      a:       str						,      a:       str						,      a:       Tuple						,      a:       str						,      a:       int						,      ):
       __lowerCamelCase		:							Optional[int]							=						True
       __lowerCamelCase		:							Optional[int]							=						RemBertModel(a				)
       model.to(a				)
       model.eval()
       __lowerCamelCase		:							str							=						model(
           a						,      attention_mask=a						,      token_type_ids=a						,      encoder_hidden_states=a						,      encoder_attention_mask=a						,      )
       __lowerCamelCase		:							Union[str, Any]							=						model(
           a						,      attention_mask=a						,      token_type_ids=a						,      encoder_hidden_states=a						,      )
       __lowerCamelCase		:							List[str]							=						model(a						,      attention_mask=a						,      token_type_ids=a				)
       self.parent.assertEqual(result.last_hidden_state.shape						,      (self.batch_size, self.seq_length, self.hidden_size)				)




      def      _snake_case	(				self:       List[str]						,      a:       Optional[Any]						,      a:       Union[str, Any]						,      a:       List[str]						,      a:       Any						,      a:       Dict						,      a:       List[Any]						,      a:       Optional[int]						,      a:       Any						,      a:       str						,      ):
       __lowerCamelCase		:							Dict							=						RemBertForCausalLM(config=a				)
       model.to(a				)
       model.eval()
       __lowerCamelCase		:							Union[str, Any]							=						model(a						,      attention_mask=a						,      token_type_ids=a						,      labels=a				)
       self.parent.assertEqual(result.logits.shape						,      (self.batch_size, self.seq_length, self.vocab_size)				)




      def      _snake_case	(				self:       Optional[int]						,      a:       Tuple						,      a:       Dict						,      a:       int						,      a:       int						,      a:       Optional[int]						,      a:       Optional[int]						,      a:       int				):
       __lowerCamelCase		:							List[Any]							=						RemBertForMaskedLM(config=a				)
       model.to(a				)
       model.eval()
       __lowerCamelCase		:							str							=						model(a						,      attention_mask=a						,      token_type_ids=a						,      labels=a				)
       self.parent.assertEqual(result.logits.shape						,      (self.batch_size, self.seq_length, self.vocab_size)				)




      def      _snake_case	(				self:       Union[str, Any]						,      a:       Optional[int]						,      a:       Optional[int]						,      a:       Optional[Any]						,      a:       Tuple						,      a:       List[str]						,      a:       Optional[int]						,      a:       Union[str, Any]						,      a:       Dict						,      a:       str						,      ):
       __lowerCamelCase		:							Union[str, Any]							=						True
       __lowerCamelCase		:							List[str]							=						True
       __lowerCamelCase		:							List[Any]							=						RemBertForCausalLM(config=a				)
       model.to(a				)
       model.eval()

       # first forward pass
       __lowerCamelCase		:							Optional[int]							=						model(
           a						,      attention_mask=a						,      encoder_hidden_states=a						,      encoder_attention_mask=a						,      use_cache=a						,      )
       __lowerCamelCase		:							Optional[int]							=						outputs.past_key_values

       # create hypothetical multiple next token and extent to next_input_ids
       __lowerCamelCase		:							int							=						ids_tensor((self.batch_size, 3)						,      config.vocab_size				)
       __lowerCamelCase		:							Union[str, Any]							=						ids_tensor((self.batch_size, 3)						,      vocab_size=2				)

       # append to next input_ids and
       __lowerCamelCase		:							Any							=						torch.cat([input_ids, next_tokens]						,      dim=-1				)
       __lowerCamelCase		:							List[Any]							=						torch.cat([input_mask, next_mask]						,      dim=-1				)

       __lowerCamelCase		:							Optional[int]							=						model(
           a						,      attention_mask=a						,      encoder_hidden_states=a						,      encoder_attention_mask=a						,      output_hidden_states=a						,      )['hidden_states'][0]
       __lowerCamelCase		:							Dict							=						model(
           a						,      attention_mask=a						,      encoder_hidden_states=a						,      encoder_attention_mask=a						,      past_key_values=a						,      output_hidden_states=a						,      )['hidden_states'][0]

       # select random slice
       __lowerCamelCase		:							int							=						ids_tensor((1,)						,      output_from_past.shape[-1]				).item()
       __lowerCamelCase		:							Any							=						output_from_no_past[:, -3:, random_slice_idx].detach()
       __lowerCamelCase		:							str							=						output_from_past[:, :, random_slice_idx].detach()

       self.parent.assertTrue(output_from_past_slice.shape[1] == next_tokens.shape[1]				)

       # test that outputs are equal for slice
       self.parent.assertTrue(torch.allclose(a						,      a						,      atol=1e-3				)				)




      def      _snake_case	(				self:       Any						,      a:       Any						,      a:       Any						,      a:       Any						,      a:       Tuple						,      a:       Optional[int]						,      a:       str						,      a:       Tuple				):
       __lowerCamelCase		:							Optional[Any]							=						RemBertForQuestionAnswering(config=a				)
       model.to(a				)
       model.eval()
       __lowerCamelCase		:							Any							=						model(
           a						,      attention_mask=a						,      token_type_ids=a						,      start_positions=a						,      end_positions=a						,      )
       self.parent.assertEqual(result.start_logits.shape						,      (self.batch_size, self.seq_length)				)
       self.parent.assertEqual(result.end_logits.shape						,      (self.batch_size, self.seq_length)				)




      def      _snake_case	(				self:       List[Any]						,      a:       Optional[Any]						,      a:       Optional[int]						,      a:       Dict						,      a:       List[Any]						,      a:       Optional[Any]						,      a:       Optional[int]						,      a:       Union[str, Any]				):
       __lowerCamelCase		:							int							=						self.num_labels
       __lowerCamelCase		:							Optional[Any]							=						RemBertForSequenceClassification(a				)
       model.to(a				)
       model.eval()
       __lowerCamelCase		:							Dict							=						model(a						,      attention_mask=a						,      token_type_ids=a						,      labels=a				)
       self.parent.assertEqual(result.logits.shape						,      (self.batch_size, self.num_labels)				)




      def      _snake_case	(				self:       Dict						,      a:       Dict						,      a:       Dict						,      a:       Optional[int]						,      a:       Optional[Any]						,      a:       Union[str, Any]						,      a:       Optional[Any]						,      a:       Optional[int]				):
       __lowerCamelCase		:							Optional[int]							=						self.num_labels
       __lowerCamelCase		:							Dict							=						RemBertForTokenClassification(config=a				)
       model.to(a				)
       model.eval()
       __lowerCamelCase		:							Tuple							=						model(a						,      attention_mask=a						,      token_type_ids=a						,      labels=a				)
       self.parent.assertEqual(result.logits.shape						,      (self.batch_size, self.seq_length, self.num_labels)				)




      def      _snake_case	(				self:       Union[str, Any]						,      a:       int						,      a:       str						,      a:       Optional[Any]						,      a:       int						,      a:       Optional[int]						,      a:       Any						,      a:       Any				):
       __lowerCamelCase		:							int							=						self.num_choices
       __lowerCamelCase		:							int							=						RemBertForMultipleChoice(config=a				)
       model.to(a				)
       model.eval()
       __lowerCamelCase		:							Dict							=						input_ids.unsqueeze(1				).expand(-1						,      self.num_choices						,      -1				).contiguous()
       __lowerCamelCase		:							Tuple							=						token_type_ids.unsqueeze(1				).expand(-1						,      self.num_choices						,      -1				).contiguous()
       __lowerCamelCase		:							List[str]							=						input_mask.unsqueeze(1				).expand(-1						,      self.num_choices						,      -1				).contiguous()
       __lowerCamelCase		:							Dict							=						model(
           a						,      attention_mask=a						,      token_type_ids=a						,      labels=a						,      )
       self.parent.assertEqual(result.logits.shape						,      (self.batch_size, self.num_choices)				)




      def      _snake_case	(				self:       Any				):
       __lowerCamelCase		:							Optional[int]							=						self.prepare_config_and_inputs()
       (
           (
           __lowerCamelCase
       )					,     (
           __lowerCamelCase
       )					,     (
           __lowerCamelCase
       )					,     (
           __lowerCamelCase
       )					,     (
           __lowerCamelCase
       )					,     (
           __lowerCamelCase
       )					,     (
           __lowerCamelCase
       )					,     
       )		:							Tuple							=						config_and_inputs
       __lowerCamelCase		:							Optional[Any]							=						{'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': input_mask}
       return config, inputs_dict



@require_torch
class        A_					(       __UpperCamelCase					,      __UpperCamelCase					,      unittest.TestCase    ):




      '''simple docstring'''


      __snake_case					       =   (
          (
              RemBertModel,
              RemBertForMaskedLM,
              RemBertForCausalLM,
              RemBertForMultipleChoice,
              RemBertForQuestionAnswering,
              RemBertForSequenceClassification,
              RemBertForTokenClassification,
          )
          if is_torch_available()
          else ()
      )
      __snake_case					       =   (RemBertForCausalLM,) if is_torch_available() else ()
      __snake_case					       =   (
          {
              """feature-extraction""": RemBertModel,
              """fill-mask""": RemBertForMaskedLM,
              """question-answering""": RemBertForQuestionAnswering,
              """text-classification""": RemBertForSequenceClassification,
              """text-generation""": RemBertForCausalLM,
              """token-classification""": RemBertForTokenClassification,
              """zero-shot""": RemBertForSequenceClassification,
          }
          if is_torch_available()
          else {}
      )




      def      _snake_case	(				self:       Tuple				):
       __lowerCamelCase		:							Tuple							=						RemBertModelTester(self				)
       __lowerCamelCase		:							int							=						ConfigTester(self						,      config_class=a						,      hidden_size=37				)




      def      _snake_case	(				self:       Any				):
       self.config_tester.run_common_tests()




      def      _snake_case	(				self:       List[Any]				):
       __lowerCamelCase		:							List[Any]							=						self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*a				)




      def      _snake_case	(				self:       Dict				):
       __lowerCamelCase		:							Optional[Any]							=						self.model_tester.prepare_config_and_inputs()
       for type in ["absolute", "relative_key", "relative_key_query"]:
        __lowerCamelCase		:							Any							=						type
        self.model_tester.create_and_check_model(*a				)




      def      _snake_case	(				self:       Dict				):
       __lowerCamelCase		:							List[str]							=						self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_masked_lm(*a				)




      def      _snake_case	(				self:       Optional[Any]				):
       __lowerCamelCase		:							Tuple							=						self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_multiple_choice(*a				)




      def      _snake_case	(				self:       List[str]				):
       __lowerCamelCase		:							List[Any]							=						self.model_tester.prepare_config_and_inputs_for_decoder()
       self.model_tester.create_and_check_decoder_model_past_large_inputs(*a				)




      def      _snake_case	(				self:       int				):
       __lowerCamelCase		:							Union[str, Any]							=						self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_question_answering(*a				)




      def      _snake_case	(				self:       Dict				):
       __lowerCamelCase		:							Optional[Any]							=						self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_sequence_classification(*a				)




      def      _snake_case	(				self:       Union[str, Any]				):
       __lowerCamelCase		:							Any							=						self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_token_classification(*a				)




      def      _snake_case	(				self:       int				):
       __lowerCamelCase		:							str							=						self.model_tester.prepare_config_and_inputs_for_decoder()
       self.model_tester.create_and_check_model_as_decoder(*a				)




      def      _snake_case	(				self:       int				):
       # This regression test was failing with PyTorch < 1.3
       (
           (
           __lowerCamelCase
       )					,     (
           __lowerCamelCase
       )					,     (
           __lowerCamelCase
       )					,     (
           __lowerCamelCase
       )					,     (
           __lowerCamelCase
       )					,     (
           __lowerCamelCase
       )					,     (
           __lowerCamelCase
       )					,     (
           __lowerCamelCase
       )					,     (
           __lowerCamelCase
       )					,     
       )		:							Optional[Any]							=						self.model_tester.prepare_config_and_inputs_for_decoder()

       __lowerCamelCase		:							List[str]							=						None

       self.model_tester.create_and_check_model_as_decoder(
           a						,      a						,      a						,      a						,      a						,      a						,      a						,      a						,      a						,      )




      @slow
      def      _snake_case	(				self:       Any				):
       for model_name in REMBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
        __lowerCamelCase		:							Tuple							=						RemBertModel.from_pretrained(a				)
        self.assertIsNotNone(a				)



@require_torch
class        A_					(       unittest.TestCase    ):




      '''simple docstring'''


      @slow
      def      _snake_case	(				self:       Any				):
       # Test exact values at the last hidden layer
       __lowerCamelCase		:							Union[str, Any]							=						RemBertModel.from_pretrained('google/rembert'				)
       __lowerCamelCase		:							int							=						torch.tensor([[312, 5_6498, 313, 2125, 313]]				)
       __lowerCamelCase		:							List[str]							=						torch.tensor([[0, 0, 0, 1, 1]]				)
       with torch.no_grad():
        __lowerCamelCase		:							List[Any]							=						model(a						,      token_type_ids=a						,      output_hidden_states=a				)

       __lowerCamelCase		:							List[Any]							=						1152

       __lowerCamelCase		:							str							=						torch.Size((1, 5, hidden_size)				)
       self.assertEqual(output['last_hidden_state'].shape						,      a				)

       __lowerCamelCase		:							int							=						torch.tensor(
           [
               [
                   [0.0_7_5_4, -0.2_0_2_2, 0.1_9_0_4],
                   [-0.3_3_5_4, -0.3_6_9_2, -0.4_7_9_1],
                   [-0.2_3_1_4, -0.6_7_2_9, -0.0_7_4_9],
                   [-0.0_3_9_6, -0.3_1_0_5, -0.4_2_3_4],
                   [-0.1_5_7_1, -0.0_5_2_5, 0.5_3_5_3],
               ]
           ]				)

       # Running on the original tf implementation gives slightly different results here.
       # Not clear why this variations is present
       # TODO: Find reason for discrepancy
       # expected_original_implementation = [[
       #     [0.07630594074726105, -0.20146065950393677, 0.19107051193714142],
       #     [-0.3405614495277405, -0.36971670389175415, -0.4808273911476135],
       #     [-0.22587086260318756, -0.6656315922737122, -0.07844287157058716],
       #     [-0.04145475849509239, -0.3077218234539032, -0.42316967248916626],
       #     [-0.15887849032878876, -0.054529931396245956, 0.5356100797653198]
       # ]]

       self.assertTrue(torch.allclose(output['last_hidden_state'][:, :, :3]						,      a						,      atol=1e-4				)				)





def       UpperCamelCase__     (  SCREAMING_SNAKE_CASE__ = 100						):
 __lowerCamelCase		:							List[Any]							=						[[0 for _ in range(SCREAMING_SNAKE_CASE__						)] for _ in range(m + 1						)]
 for i in range(m + 1						):
  __lowerCamelCase		:							Any							=						1

 for n in range(m + 1						):
  for k in range(1			,       SCREAMING_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())))

