

'''simple docstring'''

import unittest

import numpy as np
import timeout_decorator  # noqa

from transformers import BlenderbotSmallConfig, is_flax_available
from transformers.testing_utils import require_flax, slow

from ...generation.test_flax_utils import FlaxGenerationTesterMixin
from ...test_modeling_flax_common import FlaxModelTesterMixin, ids_tensor


if is_flax_available():
       import os

       # The slow tests are often failing with OOM error on GPU
       # This makes JAX allocate exactly what is needed on demand, and deallocate memory that is no longer needed
       # but will be slower as stated here https://jax.readthedocs.io/en/latest/gpu_memory_allocation.html
       UpperCAmelCase					 =	'''platform'''

       import jax
       import jax.numpy as jnp

       from transformers.models.blenderbot_small.modeling_flax_blenderbot_small import (
           FlaxBlenderbotSmallForConditionalGeneration,
           FlaxBlenderbotSmallModel,
           shift_tokens_right,
       )

def 					__UpperCamelCase				(						lowercase__    :	Tuple,       lowercase__    :	List[Any],       lowercase__    :	int=None,       lowercase__    :	List[Any]=None,       lowercase__    :	int=None,       lowercase__    :	Tuple=None,       lowercase__    :	int=None,       lowercase__    :	Optional[Any]=None,       ):






     '''simple docstring'''





     if attention_mask is None:
          __lowercase      		=np.where(input_ids != config.pad_token_id,       1,       0			)
     if decoder_attention_mask is None:
          __lowercase      		=np.where(decoder_input_ids != config.pad_token_id,       1,       0			)
     if head_mask is None:
          __lowercase      		=np.ones((config.encoder_layers, config.encoder_attention_heads)			)
     if decoder_head_mask is None:
          __lowercase      		=np.ones((config.decoder_layers, config.decoder_attention_heads)			)
     if cross_attn_head_mask is None:
          __lowercase      		=np.ones((config.decoder_layers, config.decoder_attention_heads)			)
     return {
         "input_ids": input_ids,
         "decoder_input_ids": decoder_input_ids,
         "attention_mask": attention_mask,
         "decoder_attention_mask": attention_mask,
     }


class 	lowerCAmelCase  :







       def __init__(				self      :			Optional[Any]    ,   __lowercase      :			Any    ,   __lowercase      :			str=13    ,   __lowercase      :			Union[str, Any]=7    ,   __lowercase      :			Tuple=True    ,   __lowercase      :			Any=False    ,   __lowercase      :			Union[str, Any]=99    ,   __lowercase      :			Union[str, Any]=16    ,   __lowercase      :			Any=2    ,   __lowercase      :			Optional[Any]=4    ,   __lowercase      :			List[str]=4    ,   __lowercase      :			Union[str, Any]="gelu"    ,   __lowercase      :			str=0.1    ,   __lowercase      :			str=0.1    ,   __lowercase      :			Any=32    ,   __lowercase      :			str=2    ,   __lowercase      :			Optional[int]=1    ,   __lowercase      :			List[Any]=0    ,   __lowercase      :			Optional[int]=0.0_2    ,   ):







            """simple docstring"""







            __lowercase      		=parent
            __lowercase      		=batch_size
            __lowercase      		=seq_length
            __lowercase      		=is_training
            __lowercase      		=use_labels
            __lowercase      		=vocab_size
            __lowercase      		=hidden_size
            __lowercase      		=num_hidden_layers
            __lowercase      		=num_attention_heads
            __lowercase      		=intermediate_size
            __lowercase      		=hidden_act
            __lowercase      		=hidden_dropout_prob
            __lowercase      		=attention_probs_dropout_prob
            __lowercase      		=max_position_embeddings
            __lowercase      		=eos_token_id
            __lowercase      		=pad_token_id
            __lowercase      		=bos_token_id
            __lowercase      		=initializer_range







       def       snake_case (				self      :			Optional[int]   ):







            """simple docstring"""







            __lowercase      		=np.clip(ids_tensor([self.batch_size, self.seq_length - 1]    ,   self.vocab_size   )    ,   3    ,   self.vocab_size   )
            __lowercase      		=np.concatenate((input_ids, 2 * np.ones((self.batch_size, 1)    ,   dtype=np.intaa   ))    ,   -1   )

            __lowercase      		=shift_tokens_right(__lowercase    ,   1    ,   2   )

            __lowercase      		=BlenderbotSmallConfig(
                vocab_size=self.vocab_size    ,   d_model=self.hidden_size    ,   encoder_layers=self.num_hidden_layers    ,   decoder_layers=self.num_hidden_layers    ,   encoder_attention_heads=self.num_attention_heads    ,   decoder_attention_heads=self.num_attention_heads    ,   encoder_ffn_dim=self.intermediate_size    ,   decoder_ffn_dim=self.intermediate_size    ,   dropout=self.hidden_dropout_prob    ,   attention_dropout=self.attention_probs_dropout_prob    ,   max_position_embeddings=self.max_position_embeddings    ,   eos_token_id=self.eos_token_id    ,   bos_token_id=self.bos_token_id    ,   pad_token_id=self.pad_token_id    ,   initializer_range=self.initializer_range    ,   use_cache=__lowercase    ,   )
            __lowercase      		=prepare_blenderbot_inputs_dict(__lowercase    ,   __lowercase    ,   __lowercase   )
            return config, inputs_dict







       def       snake_case (				self      :			Union[str, Any]   ):







            """simple docstring"""







            __lowercase		,  __lowercase      		=self.prepare_config_and_inputs()
            return config, inputs_dict







       def       snake_case (				self      :			Optional[int]    ,   __lowercase      :			Tuple    ,   __lowercase      :			Optional[Any]    ,   __lowercase      :			int   ):







            """simple docstring"""







            __lowercase      		=20
            __lowercase      		=model_class_name(__lowercase   )

            __lowercase      		=model.encode(inputs_dict['input_ids']   )

            __lowercase		,  __lowercase      		=(
                inputs_dict['decoder_input_ids'],
                inputs_dict['decoder_attention_mask'],
            )

            __lowercase      		=model.init_cache(decoder_input_ids.shape[0]    ,   __lowercase    ,   __lowercase   )
            __lowercase      		=jnp.ones((decoder_input_ids.shape[0], max_decoder_length)    ,   dtype='i4'   )

            __lowercase      		=jnp.broadcast_to(
                jnp.arange(decoder_input_ids.shape[-1] - 1   )[None, :]    ,   (decoder_input_ids.shape[0], decoder_input_ids.shape[-1] - 1)    ,   )
            __lowercase      		=model.decode(
                decoder_input_ids[:, :-1]    ,   __lowercase    ,   decoder_attention_mask=__lowercase    ,   past_key_values=__lowercase    ,   decoder_position_ids=__lowercase    ,   )

            __lowercase      		=jnp.array(decoder_input_ids.shape[0] * [[decoder_input_ids.shape[-1] - 1]]    ,   dtype='i4'   )
            __lowercase      		=model.decode(
                decoder_input_ids[:, -1:]    ,   __lowercase    ,   decoder_attention_mask=__lowercase    ,   past_key_values=outputs_cache.past_key_values    ,   decoder_position_ids=__lowercase    ,   )

            __lowercase      		=model.decode(__lowercase    ,   __lowercase   )

            __lowercase      		=np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5])   )   )
            self.parent.assertTrue(diff < 1E-3    ,   msg=f'''Max diff is {diff}'''   )







       def       snake_case (				self      :			List[str]    ,   __lowercase      :			List[str]    ,   __lowercase      :			Any    ,   __lowercase      :			List[Any]   ):







            """simple docstring"""







            __lowercase      		=20
            __lowercase      		=model_class_name(__lowercase   )

            __lowercase      		=model.encode(inputs_dict['input_ids']   )

            __lowercase		,  __lowercase      		=(
                inputs_dict['decoder_input_ids'],
                inputs_dict['decoder_attention_mask'],
            )

            __lowercase      		=jnp.concatenate(
                [
                    decoder_attention_mask,
                    jnp.zeros((decoder_attention_mask.shape[0], max_decoder_length - decoder_attention_mask.shape[1])   ),
                ]    ,   axis=-1    ,   )

            __lowercase      		=model.init_cache(decoder_input_ids.shape[0]    ,   __lowercase    ,   __lowercase   )
            __lowercase      		=jnp.broadcast_to(
                jnp.arange(decoder_input_ids.shape[-1] - 1   )[None, :]    ,   (decoder_input_ids.shape[0], decoder_input_ids.shape[-1] - 1)    ,   )

            __lowercase      		=model.decode(
                decoder_input_ids[:, :-1]    ,   __lowercase    ,   decoder_attention_mask=__lowercase    ,   past_key_values=__lowercase    ,   decoder_position_ids=__lowercase    ,   )
            __lowercase      		=jnp.array(decoder_input_ids.shape[0] * [[decoder_input_ids.shape[-1] - 1]]    ,   dtype='i4'   )
            __lowercase      		=model.decode(
                decoder_input_ids[:, -1:]    ,   __lowercase    ,   past_key_values=outputs_cache.past_key_values    ,   decoder_attention_mask=__lowercase    ,   decoder_position_ids=__lowercase    ,   )

            __lowercase      		=model.decode(__lowercase    ,   __lowercase    ,   decoder_attention_mask=__lowercase   )

            __lowercase      		=np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5])   )   )
            self.parent.assertTrue(diff < 1E-3    ,   msg=f'''Max diff is {diff}'''   )






@require_flax
class 	lowerCAmelCase  (   unittest.TestCase ):
       lowerCAmelCase_												=			9_9







       def       snake_case (				self      :			Dict   ):







            """simple docstring"""







            __lowercase      		=np.array(
                [
                    [71, 82, 18, 33, 46, 91, 2],
                    [68, 34, 26, 58, 30, 82, 2],
                    [5, 97, 17, 39, 94, 40, 2],
                    [76, 83, 94, 25, 70, 78, 2],
                    [87, 59, 41, 35, 48, 66, 2],
                    [55, 13, 16, 58, 5, 2, 1],  # note padding
                    [64, 27, 31, 51, 12, 75, 2],
                    [52, 64, 86, 17, 83, 39, 2],
                    [48, 61, 9, 24, 71, 82, 2],
                    [26, 1, 60, 48, 22, 13, 2],
                    [21, 5, 62, 28, 14, 76, 2],
                    [45, 98, 37, 86, 59, 48, 2],
                    [70, 70, 50, 9, 28, 0, 2],
                ]    ,   dtype=np.intaa    ,   )

            __lowercase      		=input_ids.shape[0]
            __lowercase      		=BlenderbotSmallConfig(
                vocab_size=self.vocab_size    ,   d_model=24    ,   encoder_layers=2    ,   decoder_layers=2    ,   encoder_attention_heads=2    ,   decoder_attention_heads=2    ,   encoder_ffn_dim=32    ,   decoder_ffn_dim=32    ,   max_position_embeddings=48    ,   eos_token_id=2    ,   pad_token_id=1    ,   bos_token_id=0    ,   )
            return config, input_ids, batch_size







       def       snake_case (				self      :			Tuple   ):







            """simple docstring"""







            __lowercase		,  __lowercase		,  __lowercase      		=self._get_config_and_data()
            __lowercase      		=FlaxBlenderbotSmallForConditionalGeneration(__lowercase   )
            __lowercase      		=lm_model(input_ids=__lowercase   )
            __lowercase      		=(batch_size, input_ids.shape[1], config.vocab_size)
            self.assertEqual(outputs['logits'].shape    ,   __lowercase   )







       def       snake_case (				self      :			str   ):







            """simple docstring"""







            __lowercase      		=BlenderbotSmallConfig(
                vocab_size=self.vocab_size    ,   d_model=14    ,   encoder_layers=2    ,   decoder_layers=2    ,   encoder_attention_heads=2    ,   decoder_attention_heads=2    ,   encoder_ffn_dim=8    ,   decoder_ffn_dim=8    ,   max_position_embeddings=48    ,   )
            __lowercase      		=FlaxBlenderbotSmallForConditionalGeneration(__lowercase   )
            __lowercase      		=np.array([[71, 82, 18, 33, 46, 91, 2], [68, 34, 26, 58, 30, 2, 1]]    ,   dtype=np.intaa   )
            __lowercase      		=np.array([[82, 71, 82, 18, 2], [58, 68, 2, 1, 1]]    ,   dtype=np.intaa   )
            __lowercase      		=lm_model(input_ids=__lowercase    ,   decoder_input_ids=__lowercase   )
            __lowercase      		=(*summary.shape, config.vocab_size)
            self.assertEqual(outputs['logits'].shape    ,   __lowercase   )







       def       snake_case (				self      :			List[str]   ):







            """simple docstring"""







            __lowercase      		=np.array([[71, 82, 18, 33, 2, 1, 1], [68, 34, 26, 58, 30, 82, 2]]    ,   dtype=np.intaa   )
            __lowercase      		=shift_tokens_right(__lowercase    ,   1    ,   2   )
            __lowercase      		=np.equal(__lowercase    ,   1   ).astype(np.floataa   ).sum()
            __lowercase      		=np.equal(__lowercase    ,   1   ).astype(np.floataa   ).sum()
            self.assertEqual(shifted.shape    ,   input_ids.shape   )
            self.assertEqual(__lowercase    ,   n_pad_before - 1   )
            self.assertTrue(np.equal(shifted[:, 0]    ,   2   ).all()   )






@require_flax
class 	lowerCAmelCase  (   A ,      unittest.TestCase ,      A ):
       lowerCAmelCase_												=			True
       lowerCAmelCase_												=			(
           (
               FlaxBlenderbotSmallModel,
               FlaxBlenderbotSmallForConditionalGeneration,
           )
           if is_flax_available()
           else ()
       )
       lowerCAmelCase_												=			(FlaxBlenderbotSmallForConditionalGeneration,) if is_flax_available() else ()







       def       snake_case (				self      :			str   ):







            """simple docstring"""







            __lowercase      		=FlaxBlenderbotSmallModelTester(self   )







       def       snake_case (				self      :			Optional[Any]   ):







            """simple docstring"""







            __lowercase		,  __lowercase      		=self.model_tester.prepare_config_and_inputs()
            for model_class in self.all_model_classes:
                 self.model_tester.check_use_cache_forward(__lowercase    ,   __lowercase    ,   __lowercase   )







       def       snake_case (				self      :			Tuple   ):







            """simple docstring"""







            __lowercase		,  __lowercase      		=self.model_tester.prepare_config_and_inputs()
            for model_class in self.all_model_classes:
                 self.model_tester.check_use_cache_forward_with_attn_mask(__lowercase    ,   __lowercase    ,   __lowercase   )







       def       snake_case (				self      :			List[Any]   ):







            """simple docstring"""







            __lowercase		,  __lowercase      		=self.model_tester.prepare_config_and_inputs_for_common()

            for model_class in self.all_model_classes:
                 with self.subTest(model_class.__name__   ):
                      __lowercase      		=self._prepare_for_class(__lowercase    ,   __lowercase   )
                      __lowercase      		=model_class(__lowercase   )

                      @jax.jit
                      def encode_jitted(__lowercase      :			List[Any]    ,   __lowercase      :			Optional[Any]=None    ,   **__lowercase      :			str   ):
                           return model.encode(input_ids=__lowercase    ,   attention_mask=__lowercase   )

                      with self.subTest('JIT Enabled'   ):
                           __lowercase      		=encode_jitted(**__lowercase   ).to_tuple()

                      with self.subTest('JIT Disabled'   ):
                           with jax.disable_jit():
                                __lowercase      		=encode_jitted(**__lowercase   ).to_tuple()

                      self.assertEqual(len(__lowercase   )    ,   len(__lowercase   )   )
                      for jitted_output, output in zip(__lowercase    ,   __lowercase   ):
                           self.assertEqual(jitted_output.shape    ,   output.shape   )







       def       snake_case (				self      :			Optional[int]   ):







            """simple docstring"""







            __lowercase		,  __lowercase      		=self.model_tester.prepare_config_and_inputs_for_common()

            for model_class in self.all_model_classes:
                 with self.subTest(model_class.__name__   ):
                      __lowercase      		=model_class(__lowercase   )
                      __lowercase      		=model.encode(inputs_dict['input_ids']    ,   inputs_dict['attention_mask']   )

                      __lowercase      		={
                          'decoder_input_ids': inputs_dict['decoder_input_ids'],
                          'decoder_attention_mask': inputs_dict['decoder_attention_mask'],
                          'encoder_outputs': encoder_outputs,
                      }

                      @jax.jit
                      def decode_jitted(__lowercase      :			str    ,   __lowercase      :			Any    ,   __lowercase      :			List[str]   ):
                           return model.decode(
                               decoder_input_ids=__lowercase    ,   decoder_attention_mask=__lowercase    ,   encoder_outputs=__lowercase    ,   )

                      with self.subTest('JIT Enabled'   ):
                           __lowercase      		=decode_jitted(**__lowercase   ).to_tuple()

                      with self.subTest('JIT Disabled'   ):
                           with jax.disable_jit():
                                __lowercase      		=decode_jitted(**__lowercase   ).to_tuple()

                      self.assertEqual(len(__lowercase   )    ,   len(__lowercase   )   )
                      for jitted_output, output in zip(__lowercase    ,   __lowercase   ):
                           self.assertEqual(jitted_output.shape    ,   output.shape   )







       @slow
       def       snake_case (				self      :			List[Any]   ):







            """simple docstring"""







            for model_class_name in self.all_model_classes:
                 __lowercase      		=model_class_name.from_pretrained('facebook/blenderbot_small-90M'   )
                 # FlaxBlenderbotForSequenceClassification expects eos token in input_ids
                 __lowercase      		=np.ones((1, 1)   ) * model.config.eos_token_id
                 __lowercase      		=model(__lowercase   )
                 self.assertIsNotNone(__lowercase   )





'''simple docstring'''

def 					__UpperCamelCase				(						lowercase__    :	int			):






     '''simple docstring'''





     if n == 1 or not isinstance(lowercase__,       lowercase__			):
          return 0
     elif n == 2:
          return 1
     else:
          __lowercase      		=[0, 1]
          for i in range(2,       n + 1			):
               sequence.append(sequence[i - 1] + sequence[i - 2]			)

          return sequence[n]

def 					__UpperCamelCase				(						lowercase__    :	int			):






     '''simple docstring'''





     __lowercase      		=0
     __lowercase      		=2

     while digits < n:
          index += 1
          __lowercase      		=len(str(fibonacci(lowercase__			)			)			)

     return index

def 					__UpperCamelCase				(						lowercase__    :	int = 10_00			):






     '''simple docstring'''





     return fibonacci_digits_index(lowercase__			)


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


