


from __future__ import annotations

import copy
import os
import tempfile
from importlib import import_module
from math import isnan

from transformers import is_tf_available
from transformers.models.auto import get_values
from transformers.testing_utils import _tf_gpu_memory_limit, require_tf, slow

from ..test_modeling_tf_common import ids_tensor


if is_tf_available():
       import numpy as np
       import tensorflow as tf

       from transformers import (
           TF_MODEL_FOR_CAUSAL_LM_MAPPING,
           TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
           TF_MODEL_FOR_MASKED_LM_MAPPING,
           TF_MODEL_FOR_MULTIPLE_CHOICE_MAPPING,
           TF_MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING,
           TF_MODEL_FOR_PRETRAINING_MAPPING,
           TF_MODEL_FOR_QUESTION_ANSWERING_MAPPING,
           TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
           TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
           TF_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
           TFSharedEmbeddings,
       )

       if _tf_gpu_memory_limit is not None:
              lowercase_           =	tf.config.list_physical_devices('GPU')
              for gpu in gpus:
                     # Restrict TensorFlow to only allocate x GB of memory on the GPUs
                     try:
                            tf.config.set_logical_device_configuration(
                                gpu, [tf.config.LogicalDeviceConfiguration(memory_limit=_tf_gpu_memory_limit)]
                            )
                            lowercase_           =	tf.config.list_logical_devices('GPU')
                            print('Logical GPUs', logical_gpus)
                     except RuntimeError as e:
                            # Virtual devices must be set before GPUs have been initialized
                            print(e)


@require_tf
class        A_					:




      '''simple docstring'''


      __snake_case					       =   None
      __snake_case					       =   ()
      __snake_case					       =   ()
      __snake_case					       =   True
      __snake_case					       =   True
      __snake_case					       =   True
      __snake_case					       =   False




      def      _snake_case	(				self:       Tuple						,      a:       Any						,      a:       Dict						,      a:       Union[str, Any]=False				):
       __lowerCamelCase		:							str							=						copy.deepcopy(a				)

       if model_class in get_values(a				):
        __lowerCamelCase		:							int							=						{
            k: tf.tile(tf.expand_dims(a						,      1				)						,      (1, self.model_tester.num_choices) + (1,) * (v.ndim - 1)				)
            if isinstance(a						,      tf.Tensor				) and v.ndim > 0
            else v
            for k, v in inputs_dict.items()
        }

       if return_labels:
        if model_class in get_values(a				):
         __lowerCamelCase		:							Any							=						tf.ones(self.model_tester.batch_size						,      dtype=tf.intaa				)
        elif model_class in get_values(a				):
         __lowerCamelCase		:							Union[str, Any]							=						tf.zeros(self.model_tester.batch_size						,      dtype=tf.intaa				)
         __lowerCamelCase		:							Optional[int]							=						tf.zeros(self.model_tester.batch_size						,      dtype=tf.intaa				)
        elif model_class in [
            *get_values(a				),
            *get_values(a				),
        ]:
         __lowerCamelCase		:							List[str]							=						tf.zeros(self.model_tester.batch_size						,      dtype=tf.intaa				)
        elif model_class in get_values(a				):
         __lowerCamelCase		:							int							=						tf.zeros(self.model_tester.batch_size						,      dtype=tf.intaa				)
        elif model_class in [
            *get_values(a				),
            *get_values(a				),
            *get_values(a				),
            *get_values(a				),
            *get_values(a				),
        ]:
         __lowerCamelCase		:							Union[str, Any]							=						tf.zeros(
             (self.model_tester.batch_size, self.model_tester.seq_length)						,      dtype=tf.intaa				)
       return inputs_dict




      @slow
      def      _snake_case	(				self:       str				):
       __lowerCamelCase					,     __lowerCamelCase		:							Dict							=						self.model_tester.prepare_config_and_inputs_for_common()
       for model_class in self.all_model_classes[:2]:
        __lowerCamelCase		:							Optional[Any]							=						self._prepare_for_class(a						,      a				)
        __lowerCamelCase		:							List[Any]							=						model_class(a				)

        @tf.function
        def run_in_graph_mode():
         return model(a				)

        __lowerCamelCase		:							Optional[int]							=						run_in_graph_mode()
        self.assertIsNotNone(a				)




      @slow
      def      _snake_case	(				self:       Optional[Any]				):
       __lowerCamelCase					,     __lowerCamelCase		:							Optional[int]							=						self.model_tester.prepare_config_and_inputs_for_common()
       for model_class in self.all_model_classes[:2]:
        __lowerCamelCase		:							str							=						self._prepare_for_class(a						,      a				)
        __lowerCamelCase		:							List[str]							=						model_class(a				)

        @tf.function(experimental_compile=a				)
        def run_in_graph_mode():
         return model(a				)

        __lowerCamelCase		:							Union[str, Any]							=						run_in_graph_mode()
        self.assertIsNotNone(a				)




      @slow
      def      _snake_case	(				self:       Optional[Any]				):
       # This is a copy of the test_keras_fit method, but we use XLA compilation instead of eager
       __lowerCamelCase					,     __lowerCamelCase		:							Union[str, Any]							=						self.model_tester.prepare_config_and_inputs_for_common()
       for model_class in self.all_model_classes[:2]:
        __lowerCamelCase		:							List[str]							=						model_class(a				)
        if getattr(a						,      'hf_compute_loss'						,      a				):
         # Test that model correctly compute the loss with kwargs
         __lowerCamelCase		:							Dict							=						self._prepare_for_class(inputs_dict.copy()						,      a						,      return_labels=a				)
         # Is there a better way to remove these decoder inputs?
         __lowerCamelCase		:							str							=						{
             key: val
             for key, val in prepared_for_class.items()
             if key not in ('head_mask', 'decoder_head_mask', 'cross_attn_head_mask', 'decoder_input_ids')
         }

         __lowerCamelCase		:							Optional[int]							=						{
             'labels',
             'label',
             'label_ids',
             'start_positions',
             'start_position',
             'end_positions',
             'end_position',
             'next_sentence_label',
         }
         __lowerCamelCase		:							Union[str, Any]							=						possible_label_cols.intersection(set(a				)				)
         self.assertGreater(len(a				)						,      0						,      msg='No matching label names found!'				)
         __lowerCamelCase		:							Optional[Any]							=						{key: val for key, val in prepared_for_class.items() if key in label_names}
         __lowerCamelCase		:							Optional[Any]							=						{key: val for key, val in prepared_for_class.items() if key not in label_names}
         self.assertGreater(len(a				)						,      0				)

         # Make sure it works with XLA!
         model.compile(optimizer=tf.keras.optimizers.SGD(0.0				)						,      jit_compile=a				)
         # Make sure the model fits without crashing regardless of where we pass the labels
         __lowerCamelCase		:							Optional[int]							=						model.fit(
             a						,      validation_data=a						,      steps_per_epoch=1						,      validation_steps=1						,      shuffle=a						,      verbose=0						,      )
         __lowerCamelCase		:							int							=						history.history['loss'][0]
         self.assertTrue(not isnan(a				)				)
         __lowerCamelCase		:							Optional[int]							=						history.history['val_loss'][0]
         self.assertTrue(not isnan(a				)				)

         # Now test it with separate labels, to make sure that path works in XLA too.
         __lowerCamelCase		:							List[Any]							=						model_class(a				)
         model.compile(optimizer=tf.keras.optimizers.SGD(0.0				)						,      jit_compile=a				)
         __lowerCamelCase		:							Any							=						model.fit(
             a						,      a						,      validation_data=(inputs_minus_labels, labels)						,      steps_per_epoch=1						,      validation_steps=1						,      shuffle=a						,      verbose=0						,      )

         __lowerCamelCase		:							Optional[Any]							=						history.history['loss'][0]
         self.assertTrue(not isnan(a				)				)
         __lowerCamelCase		:							Optional[int]							=						history.history['val_loss'][0]
         self.assertTrue(not isnan(a				)				)




      @slow
      def      _snake_case	(				self:       Any				):
       __lowerCamelCase					,     __lowerCamelCase		:							Dict							=						self.model_tester.prepare_config_and_inputs_for_common()
       __lowerCamelCase		:							Any							=						True
       __lowerCamelCase		:							str							=						True

       if hasattr(a						,      'use_cache'				):
        __lowerCamelCase		:							Dict							=						True

       __lowerCamelCase		:							Tuple							=						getattr(self.model_tester						,      'encoder_seq_length'						,      self.model_tester.seq_length				)
       __lowerCamelCase		:							Optional[Any]							=						getattr(self.model_tester						,      'key_length'						,      a				)

       for model_class in self.all_model_classes[:2]:
        __lowerCamelCase		:							List[Any]							=						self._prepare_for_class(a						,      a				)
        __lowerCamelCase		:							List[Any]							=						model_class(a				)
        model.build()
        __lowerCamelCase		:							Any							=						len(model(a				)				)

        for key in list(class_inputs_dict.keys()				):
         # Remove keys not in the serving signature, as the SavedModel will not be compiled to deal with them
         if key not in model.input_signature:
          del class_inputs_dict[key]
         # Check it's a tensor, in case the inputs dict has some bools in it too
         elif isinstance(class_inputs_dict[key]						,      tf.Tensor				) and class_inputs_dict[key].dtype.is_integer:
          __lowerCamelCase		:							List[Any]							=						tf.cast(class_inputs_dict[key]						,      tf.intaa				)

        if set(class_inputs_dict.keys()				) != set(model.input_signature.keys()				):
         continue  # Some models have inputs that the preparation functions don't create, we skip those

        with tempfile.TemporaryDirectory() as tmpdirname:
         model.save_pretrained(a						,      saved_model=a				)
         __lowerCamelCase		:							Optional[Any]							=						os.path.join(a						,      'saved_model'						,      '1'				)
         __lowerCamelCase		:							Optional[int]							=						tf.keras.models.load_model(a				)
         __lowerCamelCase		:							Any							=						model(a				)

         if self.is_encoder_decoder:
          __lowerCamelCase		:							Dict							=						outputs['encoder_hidden_states']
          __lowerCamelCase		:							int							=						outputs['encoder_attentions']
         else:
          __lowerCamelCase		:							int							=						outputs['hidden_states']
          __lowerCamelCase		:							Dict							=						outputs['attentions']

         self.assertEqual(len(a				)						,      a				)

         __lowerCamelCase		:							List[str]							=						getattr(
             self.model_tester						,      'expected_num_hidden_layers'						,      self.model_tester.num_hidden_layers + 1				)

         self.assertEqual(len(a				)						,      a				)
         self.assertListEqual(
             list(output_hidden_states[0].shape[-2:]				)						,      [self.model_tester.seq_length, self.model_tester.hidden_size]						,      )

         self.assertEqual(len(a				)						,      self.model_tester.num_hidden_layers				)
         self.assertListEqual(
             list(output_attentions[0].shape[-3:]				)						,      [self.model_tester.num_attention_heads, encoder_seq_length, encoder_key_length]						,      )




      @slow
      def      _snake_case	(				self:       Tuple				):
       tf.keras.mixed_precision.set_global_policy('mixed_float16'				)

       # try/finally block to ensure subsequent tests run in float32
       try:
        __lowerCamelCase					,     __lowerCamelCase		:							Any							=						self.model_tester.prepare_config_and_inputs_for_common()
        for model_class in self.all_model_classes[:2]:
         __lowerCamelCase		:							List[str]							=						self._prepare_for_class(a						,      a				)
         __lowerCamelCase		:							List[str]							=						model_class(a				)
         __lowerCamelCase		:							Union[str, Any]							=						model(a				)

         self.assertIsNotNone(a				)
       finally:
        tf.keras.mixed_precision.set_global_policy('float32'				)




      @slow
      def      _snake_case	(				self:       List[Any]				):
       __lowerCamelCase					,     __lowerCamelCase		:							List[Any]							=						self.model_tester.prepare_config_and_inputs_for_common()
       # head_mask and decoder_head_mask has different shapes than other input args
       if "head_mask" in inputs_dict:
        del inputs_dict["head_mask"]
       if "decoder_head_mask" in inputs_dict:
        del inputs_dict["decoder_head_mask"]
       if "cross_attn_head_mask" in inputs_dict:
        del inputs_dict["cross_attn_head_mask"]
       __lowerCamelCase		:							Dict							=						{
           module_member
           for model_class in self.all_model_classes
           for module in (import_module(model_class.__module__				),)
           for module_member_name in dir(a				)
           if module_member_name.endswith('MainLayer'				)
           for module_member in (getattr(a						,      a				),)
           if isinstance(a						,      a				)
           and tf.keras.layers.Layer in module_member.__bases__
           and getattr(a						,      '_keras_serializable'						,      a				)
       }

       for main_layer_class in tf_main_layer_classes:
        # T5MainLayer needs an embed_tokens parameter when called without the inputs_embeds parameter
        if "T5" in main_layer_class.__name__:
         # Take the same values than in TFT5ModelTester for this shared layer
         __lowerCamelCase		:							List[str]							=						TFSharedEmbeddings(self.model_tester.vocab_size						,      self.model_tester.hidden_size						,      name='shared'				)
         __lowerCamelCase		:							Optional[int]							=						False
         __lowerCamelCase		:							Union[str, Any]							=						main_layer_class(a						,      embed_tokens=a				)
        else:
         __lowerCamelCase		:							Optional[int]							=						main_layer_class(a				)

        __lowerCamelCase		:							Optional[int]							=						{
            name: tf.keras.Input(tensor.shape[1:]						,      dtype=tensor.dtype				) for name, tensor in inputs_dict.items()
        }

        if hasattr(self.model_tester						,      'num_labels'				):
         __lowerCamelCase		:							Any							=						self.model_tester.num_labels
        else:
         __lowerCamelCase		:							Dict							=						2

        __lowerCamelCase		:							int							=						tf.data.Dataset.from_tensor_slices(
            (inputs_dict, np.ones((self.model_tester.batch_size, self.model_tester.seq_length, num_labels, 1)				))				).batch(1				)

        __lowerCamelCase		:							Union[str, Any]							=						main_layer(a				)[0]
        __lowerCamelCase		:							Optional[int]							=						tf.keras.layers.Dense(a						,      activation='softmax'						,      name='outputs'				)(a				)
        __lowerCamelCase		:							Dict							=						tf.keras.models.Model(inputs=a						,      outputs=[outputs]				)

        model.compile(loss='binary_crossentropy'						,      optimizer='adam'						,      metrics=['binary_accuracy']				)
        model.fit(a						,      epochs=1				)

        with tempfile.TemporaryDirectory() as tmpdirname:
         __lowerCamelCase		:							Optional[int]							=						os.path.join(a						,      'keras_model.h5'				)
         model.save(a				)
         if "T5" in main_layer_class.__name__:
          __lowerCamelCase		:							Optional[int]							=						tf.keras.models.load_model(
              a						,      custom_objects={
                  main_layer_class.__name__: main_layer_class,
                  'TFSharedEmbeddings': TFSharedEmbeddings,
              }						,      )
         else:
          __lowerCamelCase		:							int							=						tf.keras.models.load_model(
              a						,      custom_objects={main_layer_class.__name__: main_layer_class}				)
         assert isinstance(a						,      tf.keras.Model				)
         model(a				)




      @slow
      def      _snake_case	(				self:       int				):
       __lowerCamelCase					,     __lowerCamelCase		:							List[Any]							=						self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes[:2]:
        __lowerCamelCase		:							Tuple							=						model_class(a				)

        __lowerCamelCase		:							List[str]							=						copy.deepcopy(a				)

        if not self.is_encoder_decoder:
         __lowerCamelCase		:							Any							=						inputs['input_ids']
         del inputs["input_ids"]
        else:
         __lowerCamelCase		:							Optional[Any]							=						inputs['input_ids']
         __lowerCamelCase		:							Tuple							=						inputs.get('decoder_input_ids'						,      a				)
         del inputs["input_ids"]
         inputs.pop('decoder_input_ids'						,      a				)

        if not self.is_encoder_decoder:
         __lowerCamelCase		:							Dict							=						model.get_input_embeddings()(a				)
        else:
         __lowerCamelCase		:							List[str]							=						model.get_input_embeddings()(a				)
         __lowerCamelCase		:							Union[str, Any]							=						model.get_input_embeddings()(a				)

        __lowerCamelCase		:							int							=						self._prepare_for_class(a						,      a				)

        @tf.function
        def run_in_graph_mode():
         return model(a				)

        __lowerCamelCase		:							Union[str, Any]							=						run_in_graph_mode()
        self.assertIsNotNone(a				)




      def      _snake_case	(				self:       Tuple						,      a:       List[str]						,      a:       Tuple				):
       # special tokens cannot be bad tokens
       __lowerCamelCase		:							str							=						[]
       if model.config.bos_token_id is not None:
        special_tokens.append(model.config.bos_token_id				)
       if model.config.pad_token_id is not None:
        special_tokens.append(model.config.pad_token_id				)
       if model.config.eos_token_id is not None:
        special_tokens.append(model.config.eos_token_id				)

       # create random bad tokens that are not special tokens
       __lowerCamelCase		:							Optional[int]							=						[]
       while len(a				) < num_bad_tokens:
        __lowerCamelCase		:							Any							=						tf.squeeze(ids_tensor((1, 1)						,      self.model_tester.vocab_size				)						,      0				).numpy()[0]
        if token not in special_tokens:
         bad_tokens.append(a				)
       return bad_tokens




      def      _snake_case	(				self:       Tuple						,      a:       Tuple				):
       for token_id in output_ids[0].numpy().tolist():
        self.assertGreaterEqual(a						,      0				)
        self.assertLess(a						,      self.model_tester.vocab_size				)




      def      _snake_case	(				self:       Tuple						,      a:       List[Any]						,      a:       str				):
       # for all bad word tokens
       for bad_word_ids in bad_words_ids:
        # for all slices in batch
        for generated_ids_slice in generated_ids:
         # for all word idx
         for i in range(len(a				)						,      len(a				)				):
          # if tokens match
          if generated_ids_slice[i - len(a				) : i] == bad_word_ids:
           return True
       return False





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

