

'''simple docstring'''

import json
import logging
import os
import sys
from pathlib import Path

import finetune_rag

from transformers.file_utils import is_apex_available
from transformers.testing_utils import (
    TestCasePlus,
    execute_subprocess_async,
    require_ray,
    require_torch_gpu,
    require_torch_multi_gpu,
)


logging.basicConfig(level=logging.DEBUG)
UpperCAmelCase					 =	logging.getLogger()

UpperCAmelCase					 =	logging.StreamHandler(sys.stdout)
logger.addHandler(stream_handler)


class 	lowerCAmelCase  (   A ):







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







            """simple docstring"""







            os.makedirs(__lowercase    ,   exist_ok=__lowercase   )
            __lowercase      		={'source': 'What is love ?', 'target': 'life'}
            __lowercase      		={'train': 12, 'val': 2, 'test': 2}
            for split in ["train", "test", "val"]:
                 for field in ["source", "target"]:
                      __lowercase      		='\n'.join([contents[field]] * n_lines[split]   )
                      with open(os.path.join(__lowercase    ,   f'''{split}.{field}'''   )    ,   'w'   ) as f:
                           f.write(__lowercase   )







       def       snake_case (				self      :			List[Any]    ,   __lowercase      :			int    ,   __lowercase      :			str = "pytorch"   ):







            """simple docstring"""







            __lowercase      		=self.get_auto_remove_tmp_dir()
            __lowercase      		=os.path.join(__lowercase    ,   'output'   )
            __lowercase      		=os.path.join(__lowercase    ,   'data'   )
            self._create_dummy_data(data_dir=__lowercase   )

            __lowercase      		=f'''
                --data_dir {data_dir} \
                --output_dir {output_dir} \
                --model_name_or_path facebook/rag-sequence-base \
                --model_type rag_sequence \
                --do_train \
                --do_predict \
                --n_val -1 \
                --val_check_interval 1.0 \
                --train_batch_size 2 \
                --eval_batch_size 1 \
                --max_source_length 25 \
                --max_target_length 25 \
                --val_max_target_length 25 \
                --test_max_target_length 25 \
                --label_smoothing 0.1 \
                --dropout 0.1 \
                --attention_dropout 0.1 \
                --weight_decay 0.001 \
                --adam_epsilon 1e-08 \
                --max_grad_norm 0.1 \
                --lr_scheduler polynomial \
                --learning_rate 3e-04 \
                --num_train_epochs 1 \
                --warmup_steps 4 \
                --gradient_accumulation_steps 1 \
                --distributed-port 8787 \
                --use_dummy_dataset 1 \
                --distributed_retriever {distributed_retriever} \
            '''.split()

            if gpus > 0:
                 testargs.append(f'''--gpus={gpus}'''   )
                 if is_apex_available():
                      testargs.append('--fp16'   )
            else:
                 testargs.append('--gpus=0'   )
                 testargs.append('--distributed_backend=ddp_cpu'   )
                 testargs.append('--num_processes=2'   )

            __lowercase      		=[sys.executable, str(Path(finetune_rag.__file__   ).resolve()   )] + testargs
            execute_subprocess_async(__lowercase    ,   env=self.get_env()   )

            __lowercase      		=os.path.join(__lowercase    ,   'metrics.json'   )
            with open(__lowercase   ) as f:
                 __lowercase      		=json.load(__lowercase   )
            return result







       @require_torch_gpu
       def       snake_case (				self      :			str   ):







            """simple docstring"""







            __lowercase      		=self._run_finetune(gpus=1   )
            self.assertGreaterEqual(result['test'][0]['test_avg_em']    ,   0.2   )







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







            """simple docstring"""







            __lowercase      		=self._run_finetune(gpus=2   )
            self.assertGreaterEqual(result['test'][0]['test_avg_em']    ,   0.2   )







       @require_torch_gpu
       @require_ray
       def       snake_case (				self      :			str   ):







            """simple docstring"""







            __lowercase      		=self._run_finetune(gpus=1    ,   distributed_retriever='ray'   )
            self.assertGreaterEqual(result['test'][0]['test_avg_em']    ,   0.2   )







       @require_torch_multi_gpu
       @require_ray
       def       snake_case (				self      :			str   ):







            """simple docstring"""







            __lowercase      		=self._run_finetune(gpus=1    ,   distributed_retriever='ray'   )
            self.assertGreaterEqual(result['test'][0]['test_avg_em']    ,   0.2   )





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


