






import unittest

import numpy as np

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

from ...test_modeling_flax_common import FlaxModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask


if is_flax_available():
   from transformers.models.roberta.modeling_flax_roberta import (
       FlaxRobertaForCausalLM,
       FlaxRobertaForMaskedLM,
       FlaxRobertaForMultipleChoice,
       FlaxRobertaForQuestionAnswering,
       FlaxRobertaForSequenceClassification,
       FlaxRobertaForTokenClassification,
       FlaxRobertaModel,
   )



class 				_A			(     unittest.TestCase				):
    """simple docstring"""

    def __init__(				self      :     Any ,     __SCREAMING_SNAKE_CASE      :     Optional[Any] ,     __SCREAMING_SNAKE_CASE      :     Optional[Any]=13 ,     __SCREAMING_SNAKE_CASE      :     Dict=7 ,     __SCREAMING_SNAKE_CASE      :     Tuple=True ,     __SCREAMING_SNAKE_CASE      :     List[str]=True ,     __SCREAMING_SNAKE_CASE      :     Optional[Any]=True ,     __SCREAMING_SNAKE_CASE      :     int=True ,     __SCREAMING_SNAKE_CASE      :     Optional[Any]=99 ,     __SCREAMING_SNAKE_CASE      :     Dict=32 ,     __SCREAMING_SNAKE_CASE      :     int=5 ,     __SCREAMING_SNAKE_CASE      :     Dict=4 ,     __SCREAMING_SNAKE_CASE      :     str=37 ,     __SCREAMING_SNAKE_CASE      :     Union[str, Any]="gelu" ,     __SCREAMING_SNAKE_CASE      :     int=0.1 ,     __SCREAMING_SNAKE_CASE      :     Union[str, Any]=0.1 ,     __SCREAMING_SNAKE_CASE      :     str=512 ,     __SCREAMING_SNAKE_CASE      :     Dict=16 ,     __SCREAMING_SNAKE_CASE      :     Any=2 ,     __SCREAMING_SNAKE_CASE      :     Union[str, Any]=0.02 ,     __SCREAMING_SNAKE_CASE      :     List[str]=4 ,     )      ->							Optional[Any]:
           __UpperCAmelCase     				=parent
           __UpperCAmelCase     				=batch_size
           __UpperCAmelCase     				=seq_length
           __UpperCAmelCase     				=is_training
           __UpperCAmelCase     				=use_attention_mask
           __UpperCAmelCase     				=use_token_type_ids
           __UpperCAmelCase     				=use_labels
           __UpperCAmelCase     				=vocab_size
           __UpperCAmelCase     				=hidden_size
           __UpperCAmelCase     				=num_hidden_layers
           __UpperCAmelCase     				=num_attention_heads
           __UpperCAmelCase     				=intermediate_size
           __UpperCAmelCase     				=hidden_act
           __UpperCAmelCase     				=hidden_dropout_prob
           __UpperCAmelCase     				=attention_probs_dropout_prob
           __UpperCAmelCase     				=max_position_embeddings
           __UpperCAmelCase     				=type_vocab_size
           __UpperCAmelCase     				=type_sequence_label_size
           __UpperCAmelCase     				=initializer_range
           __UpperCAmelCase     				=num_choices



    def _a							(				self      :     List[Any]      )      ->							List[str]:
           __UpperCAmelCase     				=ids_tensor([self.batch_size, self.seq_length] ,     self.vocab_size      )

           __UpperCAmelCase     				=None
           if self.use_attention_mask:
                  __UpperCAmelCase     				=random_attention_mask([self.batch_size, self.seq_length]      )

           __UpperCAmelCase     				=None
           if self.use_token_type_ids:
                  __UpperCAmelCase     				=ids_tensor([self.batch_size, self.seq_length] ,     self.type_vocab_size      )

           __UpperCAmelCase     				=RobertaConfig(
               vocab_size=self.vocab_size ,     hidden_size=self.hidden_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=__SCREAMING_SNAKE_CASE ,     initializer_range=self.initializer_range ,     )

           return config, input_ids, token_type_ids, attention_mask



    def _a							(				self      :     Tuple      )      ->							Optional[int]:
           __UpperCAmelCase     				=self.prepare_config_and_inputs()
           __UpperCAmelCase				, __UpperCAmelCase				, __UpperCAmelCase				, __UpperCAmelCase     				=config_and_inputs
           __UpperCAmelCase     				={"""input_ids""": input_ids, """token_type_ids""": token_type_ids, """attention_mask""": attention_mask}
           return config, inputs_dict



    def _a							(				self      :     List[str]      )      ->							Dict:
           __UpperCAmelCase     				=self.prepare_config_and_inputs()
           __UpperCAmelCase				, __UpperCAmelCase				, __UpperCAmelCase				, __UpperCAmelCase     				=config_and_inputs

           __UpperCAmelCase     				=True
           __UpperCAmelCase     				=floats_tensor([self.batch_size, self.seq_length, self.hidden_size]      )
           __UpperCAmelCase     				=ids_tensor([self.batch_size, self.seq_length] ,     vocab_size=2      )

           return (
               config,
               input_ids,
               token_type_ids,
               encoder_hidden_states,
               encoder_attention_mask,
           )




@require_flax
class 				_A			(     UpperCamelCase					,					unittest.TestCase				):
    """simple docstring"""

    lowerCamelCase	:							Union[str, Any]				= True

    lowerCamelCase	:							Union[str, Any]				= (
        (
            FlaxRobertaModel,
            FlaxRobertaForCausalLM,
            FlaxRobertaForMaskedLM,
            FlaxRobertaForSequenceClassification,
            FlaxRobertaForTokenClassification,
            FlaxRobertaForMultipleChoice,
            FlaxRobertaForQuestionAnswering,
        )
        if is_flax_available()
        else ()
    )



    def _a							(				self      :     List[Any]      )      ->							List[str]:
           __UpperCAmelCase     				=FlaxRobertaModelTester(self      )



    @slow
    def _a							(				self      :     Optional[Any]      )      ->							List[Any]:
           for model_class_name in self.all_model_classes:
                  __UpperCAmelCase     				=model_class_name.from_pretrained("""roberta-base""" ,     from_pt=__SCREAMING_SNAKE_CASE      )
                  __UpperCAmelCase     				=model(np.ones((1, 1)      )      )
                  self.assertIsNotNone(__SCREAMING_SNAKE_CASE      )









def  lowerCAmelCase_	(lowerCAmelCase__:		int  ):





			"""simple docstring"""


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

						return sequence[n]







def  lowerCAmelCase_	(lowerCAmelCase__:		int  ):





			"""simple docstring"""


			UpperCAmelCase_:		str							      =     0
			UpperCAmelCase_:		str							      =     2

			while digits < n:
						index += 1
						UpperCAmelCase_:		Union[str, Any]							      =     len(str(fibonacci(lowerCAmelCase__  )  )  )

			return index







def  lowerCAmelCase_	(lowerCAmelCase__:		int = 1_0_0_0  ):





			"""simple docstring"""


			return fibonacci_digits_index(lowerCAmelCase__  )


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






