"""simple docstring"""






import unittest

from transformers import (
    MODEL_FOR_CAUSAL_LM_MAPPING,
    TF_MODEL_FOR_CAUSAL_LM_MAPPING,
    TextGenerationPipeline,
    logging,
    pipeline,
)
from transformers.testing_utils import (
    CaptureLogger,
    is_pipeline_test,
    require_accelerate,
    require_tf,
    require_torch,
    require_torch_gpu,
    require_torch_or_tf,
)

from .test_pipelines_common import ANY


@is_pipeline_test
@require_torch_or_tf
class     UpperCAmelCase						(unittest.TestCase  ):



    """simple docstring"""

    _UpperCAmelCase	:Any						    = MODEL_FOR_CAUSAL_LM_MAPPING
    _UpperCAmelCase	:Dict						    = TF_MODEL_FOR_CAUSAL_LM_MAPPING






    @require_torch
    def _snake_case			(   self							):
       lowercase__:   Union[str, Any]					=      pipeline(task='''text-generation'''    ,			model='''sshleifer/tiny-ctrl'''    ,			framework='''pt'''							)
       # Using `do_sample=False` to force deterministic output
       lowercase__:   Any					=      text_generator('''This is a test'''    ,			do_sample=_UpperCAmelCase							)
       self.assertEqual(
           _UpperCAmelCase    ,			[
               {
                   '''generated_text''': (
                       '''This is a test ☃ ☃ segmental segmental segmental 议议eski eski flutter flutter Lacy oscope.'''
                       ''' oscope. FiliFili@@'''
                   )
               }
           ]    ,			)

       lowercase__:   Any					=      text_generator(['''This is a test''', '''This is a second test''']							)
       self.assertEqual(
           _UpperCAmelCase    ,			[
               [
                   {
                       '''generated_text''': (
                           '''This is a test ☃ ☃ segmental segmental segmental 议议eski eski flutter flutter Lacy oscope.'''
                           ''' oscope. FiliFili@@'''
                       )
                   }
               ],
               [
                   {
                       '''generated_text''': (
                           '''This is a second test ☃ segmental segmental segmental 议议eski eski flutter flutter Lacy'''
                           ''' oscope. oscope. FiliFili@@'''
                       )
                   }
               ],
           ]    ,			)

       lowercase__:   List[Any]					=      text_generator('''This is a test'''    ,			do_sample=_UpperCAmelCase    ,			num_return_sequences=2    ,			return_tensors=_UpperCAmelCase							)
       self.assertEqual(
           _UpperCAmelCase    ,			[
               {'''generated_token_ids''': ANY(_UpperCAmelCase							)},
               {'''generated_token_ids''': ANY(_UpperCAmelCase							)},
           ]    ,			)
       lowercase__:   Optional[Any]					=      text_generator.model.config.eos_token_id
       lowercase__:   Tuple					=      '''<pad>'''
       lowercase__:   List[Any]					=      text_generator(
           ['''This is a test''', '''This is a second test''']    ,			do_sample=_UpperCAmelCase    ,			num_return_sequences=2    ,			batch_size=2    ,			return_tensors=_UpperCAmelCase    ,			)
       self.assertEqual(
           _UpperCAmelCase    ,			[
               [
                   {'''generated_token_ids''': ANY(_UpperCAmelCase							)},
                   {'''generated_token_ids''': ANY(_UpperCAmelCase							)},
               ],
               [
                   {'''generated_token_ids''': ANY(_UpperCAmelCase							)},
                   {'''generated_token_ids''': ANY(_UpperCAmelCase							)},
               ],
           ]    ,			)






    @require_tf
    def _snake_case			(   self							):
       lowercase__:   Union[str, Any]					=      pipeline(task='''text-generation'''    ,			model='''sshleifer/tiny-ctrl'''    ,			framework='''tf'''							)

       # Using `do_sample=False` to force deterministic output
       lowercase__:   Any					=      text_generator('''This is a test'''    ,			do_sample=_UpperCAmelCase							)
       self.assertEqual(
           _UpperCAmelCase    ,			[
               {
                   '''generated_text''': (
                       '''This is a test FeyFeyFey(Croatis.), s.), Cannes Cannes Cannes 閲閲Cannes Cannes Cannes 攵'''
                       ''' please,'''
                   )
               }
           ]    ,			)

       lowercase__:   Optional[Any]					=      text_generator(['''This is a test''', '''This is a second test''']    ,			do_sample=_UpperCAmelCase							)
       self.assertEqual(
           _UpperCAmelCase    ,			[
               [
                   {
                       '''generated_text''': (
                           '''This is a test FeyFeyFey(Croatis.), s.), Cannes Cannes Cannes 閲閲Cannes Cannes Cannes 攵'''
                           ''' please,'''
                       )
                   }
               ],
               [
                   {
                       '''generated_text''': (
                           '''This is a second test Chieftain Chieftain prefecture prefecture prefecture Cannes Cannes'''
                           ''' Cannes 閲閲Cannes Cannes Cannes 攵 please,'''
                       )
                   }
               ],
           ]    ,			)






    def _snake_case			(   self    ,			_UpperCAmelCase    ,			_UpperCAmelCase    ,			_UpperCAmelCase							):
       lowercase__:   Optional[Any]					=      TextGenerationPipeline(model=_UpperCAmelCase    ,			tokenizer=_UpperCAmelCase							)
       return text_generator, ["This is a test", "Another test"]






    def _snake_case			(   self							):
       lowercase__:   Dict					=      '''Hello I believe in'''
       lowercase__:   Tuple					=      pipeline('''text-generation'''    ,			model='''hf-internal-testing/tiny-random-gpt2'''							)
       lowercase__:   int					=      text_generator(_UpperCAmelCase							)
       self.assertEqual(
           _UpperCAmelCase    ,			[{'''generated_text''': '''Hello I believe in fe fe fe fe fe fe fe fe fe fe fe fe'''}]    ,			)

       lowercase__:   List[Any]					=      text_generator(_UpperCAmelCase    ,			stop_sequence=''' fe'''							)
       self.assertEqual(_UpperCAmelCase    ,			[{'''generated_text''': '''Hello I believe in fe'''}]							)






    def _snake_case			(   self    ,			_UpperCAmelCase    ,			_UpperCAmelCase							):
       lowercase__:   Any					=      text_generator.model
       lowercase__:   Any					=      text_generator.tokenizer

       lowercase__:   Optional[Any]					=      text_generator('''This is a test'''							)
       self.assertEqual(_UpperCAmelCase    ,			[{'''generated_text''': ANY(_UpperCAmelCase							)}]							)
       self.assertTrue(outputs[0]['''generated_text'''].startswith('''This is a test'''							)							)

       lowercase__:   Optional[int]					=      text_generator('''This is a test'''    ,			return_full_text=_UpperCAmelCase							)
       self.assertEqual(_UpperCAmelCase    ,			[{'''generated_text''': ANY(_UpperCAmelCase							)}]							)
       self.assertNotIn('''This is a test'''    ,			outputs[0]['''generated_text''']							)

       lowercase__:   Union[str, Any]					=      pipeline(task='''text-generation'''    ,			model=_UpperCAmelCase    ,			tokenizer=_UpperCAmelCase    ,			return_full_text=_UpperCAmelCase							)
       lowercase__:   Tuple					=      text_generator('''This is a test'''							)
       self.assertEqual(_UpperCAmelCase    ,			[{'''generated_text''': ANY(_UpperCAmelCase							)}]							)
       self.assertNotIn('''This is a test'''    ,			outputs[0]['''generated_text''']							)

       lowercase__:   Tuple					=      text_generator('''This is a test'''    ,			return_full_text=_UpperCAmelCase							)
       self.assertEqual(_UpperCAmelCase    ,			[{'''generated_text''': ANY(_UpperCAmelCase							)}]							)
       self.assertTrue(outputs[0]['''generated_text'''].startswith('''This is a test'''							)							)

       lowercase__:   str					=      text_generator(['''This is great !''', '''Something else''']    ,			num_return_sequences=2    ,			do_sample=_UpperCAmelCase							)
       self.assertEqual(
           _UpperCAmelCase    ,			[
               [{'''generated_text''': ANY(_UpperCAmelCase							)}, {'''generated_text''': ANY(_UpperCAmelCase							)}],
               [{'''generated_text''': ANY(_UpperCAmelCase							)}, {'''generated_text''': ANY(_UpperCAmelCase							)}],
           ]    ,			)

       if text_generator.tokenizer.pad_token is not None:
          lowercase__:   List[Any]					=      text_generator(
              ['''This is great !''', '''Something else''']    ,			num_return_sequences=2    ,			batch_size=2    ,			do_sample=_UpperCAmelCase							)
          self.assertEqual(
              _UpperCAmelCase    ,			[
                  [{'''generated_text''': ANY(_UpperCAmelCase							)}, {'''generated_text''': ANY(_UpperCAmelCase							)}],
                  [{'''generated_text''': ANY(_UpperCAmelCase							)}, {'''generated_text''': ANY(_UpperCAmelCase							)}],
              ]    ,			)

       with self.assertRaises(_UpperCAmelCase							):
          lowercase__:   Any					=      text_generator('''test'''    ,			return_full_text=_UpperCAmelCase    ,			return_text=_UpperCAmelCase							)
       with self.assertRaises(_UpperCAmelCase							):
          lowercase__:   int					=      text_generator('''test'''    ,			return_full_text=_UpperCAmelCase    ,			return_tensors=_UpperCAmelCase							)
       with self.assertRaises(_UpperCAmelCase							):
          lowercase__:   Optional[int]					=      text_generator('''test'''    ,			return_text=_UpperCAmelCase    ,			return_tensors=_UpperCAmelCase							)

       # Empty prompt is slighly special
       # it requires BOS token to exist.
       # Special case for Pegasus which will always append EOS so will
       # work even without BOS.
       if (
           text_generator.tokenizer.bos_token_id is not None
           or "Pegasus" in tokenizer.__class__.__name__
           or "Git" in model.__class__.__name__
       ):
          lowercase__:   Any					=      text_generator(''''''							)
          self.assertEqual(_UpperCAmelCase    ,			[{'''generated_text''': ANY(_UpperCAmelCase							)}]							)
       else:
          with self.assertRaises((ValueError, AssertionError)							):
             lowercase__:   List[str]					=      text_generator(''''''							)

       if text_generator.framework == "tf":
          # TF generation does not support max_new_tokens, and it's impossible
          # to control long generation with only max_length without
          # fancy calculation, dismissing tests for now.
          return
       # We don't care about infinite range models.
       # They already work.
       # Skip this test for XGLM, since it uses sinusoidal positional embeddings which are resized on-the-fly.
       lowercase__:   Optional[int]					=      ['''RwkvForCausalLM''', '''XGLMForCausalLM''', '''GPTNeoXForCausalLM''']
       if (
           tokenizer.model_max_length < 10000
           and text_generator.model.__class__.__name__ not in EXTRA_MODELS_CAN_HANDLE_LONG_INPUTS
       ):
          # Handling of large generations
          with self.assertRaises((RuntimeError, IndexError, ValueError, AssertionError)							):
             text_generator('''This is a test''' * 500    ,			max_new_tokens=20							)

          lowercase__:   List[str]					=      text_generator('''This is a test''' * 500    ,			handle_long_generation='''hole'''    ,			max_new_tokens=20							)
          # Hole strategy cannot work
          with self.assertRaises(_UpperCAmelCase							):
             text_generator(
                 '''This is a test''' * 500    ,			handle_long_generation='''hole'''    ,			max_new_tokens=tokenizer.model_max_length + 10    ,			)






    @require_torch
    @require_accelerate
    @require_torch_gpu
    def _snake_case			(   self							):
       import torch

       # Classic `model_kwargs`
       lowercase__:   Any					=      pipeline(
           model='''hf-internal-testing/tiny-random-bloom'''    ,			model_kwargs={'''device_map''': '''auto''', '''torch_dtype''': torch.bfloataa}    ,			)
       self.assertEqual(pipe.model.device    ,			torch.device(0							)							)
       self.assertEqual(pipe.model.lm_head.weight.dtype    ,			torch.bfloataa							)
       lowercase__:   str					=      pipe('''This is a test'''							)
       self.assertEqual(
           _UpperCAmelCase    ,			[
               {
                   '''generated_text''': (
                       '''This is a test test test test test test test test test test test test test test test test'''
                       ''' test'''
                   )
               }
           ]    ,			)

       # Upgraded those two to real pipeline arguments (they just get sent for the model as they're unlikely to mean anything else.)
       lowercase__:   Dict					=      pipeline(model='''hf-internal-testing/tiny-random-bloom'''    ,			device_map='''auto'''    ,			torch_dtype=torch.bfloataa							)
       self.assertEqual(pipe.model.device    ,			torch.device(0							)							)
       self.assertEqual(pipe.model.lm_head.weight.dtype    ,			torch.bfloataa							)
       lowercase__:   List[str]					=      pipe('''This is a test'''							)
       self.assertEqual(
           _UpperCAmelCase    ,			[
               {
                   '''generated_text''': (
                       '''This is a test test test test test test test test test test test test test test test test'''
                       ''' test'''
                   )
               }
           ]    ,			)

       # torch_dtype will be automatically set to float32 if not provided - check: https://github.com/huggingface/transformers/pull/20602
       lowercase__:   Any					=      pipeline(model='''hf-internal-testing/tiny-random-bloom'''    ,			device_map='''auto'''							)
       self.assertEqual(pipe.model.device    ,			torch.device(0							)							)
       self.assertEqual(pipe.model.lm_head.weight.dtype    ,			torch.floataa							)
       lowercase__:   Any					=      pipe('''This is a test'''							)
       self.assertEqual(
           _UpperCAmelCase    ,			[
               {
                   '''generated_text''': (
                       '''This is a test test test test test test test test test test test test test test test test'''
                       ''' test'''
                   )
               }
           ]    ,			)






    @require_torch
    @require_torch_gpu
    def _snake_case			(   self							):
       import torch

       lowercase__:   Union[str, Any]					=      pipeline(model='''hf-internal-testing/tiny-random-bloom'''    ,			device=0    ,			torch_dtype=torch.floataa							)
       pipe('''This is a test'''							)






    @require_torch
    @require_accelerate
    @require_torch_gpu
    def _snake_case			(   self							):
       import torch

       lowercase__:   Union[str, Any]					=      pipeline(model='''hf-internal-testing/tiny-random-bloom'''    ,			device_map='''auto'''    ,			torch_dtype=torch.floataa							)
       pipe('''This is a test'''    ,			do_sample=_UpperCAmelCase    ,			top_p=0.5							)






    def _snake_case			(   self							):
       lowercase__:   Optional[Any]					=      '''Hello world'''
       lowercase__:   List[str]					=      pipeline('''text-generation'''    ,			model='''hf-internal-testing/tiny-random-gpt2'''							)
       if text_generator.model.framework == "tf":
          lowercase__:   List[str]					=      logging.get_logger('''transformers.generation.tf_utils'''							)
       else:
          lowercase__:   List[str]					=      logging.get_logger('''transformers.generation.utils'''							)
       lowercase__:   List[Any]					=      '''Both `max_new_tokens`'''  # The beggining of the message to be checked in this test

       # Both are set by the user -> log warning
       with CaptureLogger(_UpperCAmelCase							) as cl:
          lowercase__:   Any					=      text_generator(_UpperCAmelCase    ,			max_length=10    ,			max_new_tokens=1							)
       self.assertIn(_UpperCAmelCase    ,			cl.out							)

       # The user only sets one -> no warning
       with CaptureLogger(_UpperCAmelCase							) as cl:
          lowercase__:   List[Any]					=      text_generator(_UpperCAmelCase    ,			max_new_tokens=1							)
       self.assertNotIn(_UpperCAmelCase    ,			cl.out							)

       with CaptureLogger(_UpperCAmelCase							) as cl:
          lowercase__:   Optional[Any]					=      text_generator(_UpperCAmelCase    ,			max_length=10							)
       self.assertNotIn(_UpperCAmelCase    ,			cl.out							)

"""simple docstring"""






def SCREAMING_SNAKE_CASE__			(   __UpperCAmelCase )  ->  int:
   if n == 1 or not isinstance(__UpperCAmelCase       ,    __UpperCAmelCase ):
      return 0
   elif n == 2:
      return 1
   else:
      lowercase__:   List[Any]					=      [0, 1]
      for i in range(2       ,    n + 1 ):
         sequence.append(sequence[i - 1] + sequence[i - 2] )

      return sequence[n]



def SCREAMING_SNAKE_CASE__			(   __UpperCAmelCase )  ->  int:
   lowercase__:   Union[str, Any]					=      0
   lowercase__:   List[Any]					=      2

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

   return index



def SCREAMING_SNAKE_CASE__			(   __UpperCAmelCase = 1_0_0_0 )  ->  int:
   return fibonacci_digits_index(__UpperCAmelCase )


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