


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





							'''simple docstring'''






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







							def     __SCREAMING_SNAKE_CASE				(						self   ,       lowerCamelCase_   ,       lowerCamelCase_ = "pytorch"  )			->				List[str]:
														lowerCAmelCase__			  =      self.get_auto_remove_tmp_dir()
														lowerCAmelCase__			  =      os.path.join(lowerCamelCase_   ,       '''output'''  )
														lowerCAmelCase__			  =      os.path.join(lowerCamelCase_   ,       '''data'''  )
														self._create_dummy_data(data_dir=lowerCamelCase_  )

														lowerCAmelCase__			  =      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'''  )

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

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







							@require_torch_gpu
							def     __SCREAMING_SNAKE_CASE				(						self  )			->				Any:
														lowerCAmelCase__			  =      self._run_finetune(gpus=1  )
														self.assertGreaterEqual(result['''test'''][0]['''test_avg_em''']   ,       0.2  )







							@require_torch_multi_gpu
							def     __SCREAMING_SNAKE_CASE				(						self  )			->				Tuple:
														lowerCAmelCase__			  =      self._run_finetune(gpus=2  )
														self.assertGreaterEqual(result['''test'''][0]['''test_avg_em''']   ,       0.2  )







							@require_torch_gpu
							@require_ray
							def     __SCREAMING_SNAKE_CASE				(						self  )			->				Optional[int]:
														lowerCAmelCase__			  =      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     __SCREAMING_SNAKE_CASE				(						self  )			->				List[Any]:
														lowerCAmelCase__			  =      self._run_finetune(gpus=1   ,       distributed_retriever='''ray'''  )
														self.assertGreaterEqual(result['''test'''][0]['''test_avg_em''']   ,       0.2  )



'''simple docstring'''






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

														return sequence[n]


def    _snake_case  (	A			)		->       int:
							lowerCAmelCase__			  =      0
							lowerCAmelCase__			  =      2

							while digits < n:
														index += 1
														lowerCAmelCase__			  =      len(str(fibonacci(A			)			)			)

							return index


def    _snake_case  (	A = 1000			)		->       int:
							return fibonacci_digits_index(A			)


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