





'''simple docstring'''
import unittest
from pathlib import Path
from tempfile import NamedTemporaryFile, TemporaryDirectory

from transformers import BertConfig, BertTokenizerFast, FeatureExtractionPipeline
from transformers.convert_graph_to_onnx import (
    convert,
    ensure_valid_input,
    generate_identified_filename,
    infer_shapes,
    quantize,
)
from transformers.testing_utils import require_tf, require_tokenizers, require_torch, slow

class      snake_case     :




 """simple docstring"""



 def        _lowerCamelCase					(       self       :							Any							,	__A       :							Optional[Any]							,	__A       :							Any							,	__A       :							Union[str, Any]	):
        return None






class      snake_case     :




 """simple docstring"""



 def        _lowerCamelCase					(       self       :							Any							,	__A       :							Optional[Any]							,	__A       :							Union[str, Any]							,	__A       :							Dict							,	__A       :							Optional[int]	):
        return None






class      snake_case     (    unittest.TestCase       ):




 """simple docstring"""



 SCREAMING_SNAKE_CASE_	:					str					=[
     # (model_name, model_kwargs)
     ("bert-base-cased", {}),
     ("gpt2", {"use_cache": False}),  # We don't support exporting GPT2 past keys anymore
 ]






 @require_tf
 @slow
 def        _lowerCamelCase					(       self       :							Optional[Any]	):
        for model, model_kwargs in OnnxExportTestCase.MODEL_TO_TEST:
               self._test_export(__A							,	'tf'							,	1_2							,	**__A	)






 @require_torch
 @slow
 def        _lowerCamelCase					(       self       :							Optional[Any]	):
        for model, model_kwargs in OnnxExportTestCase.MODEL_TO_TEST:
               self._test_export(__A							,	'pt'							,	1_2							,	**__A	)






 @require_torch
 @slow
 def        _lowerCamelCase					(       self       :							Any	):
        from transformers import BertModel

        __UpperCamelCase       =  ['[UNK]', '[SEP]', '[CLS]', '[PAD]', '[MASK]', 'some', 'other', 'words']
        with NamedTemporaryFile(mode='w+t'	) as vocab_file:
               vocab_file.write('\n'.join(__A	)	)
               vocab_file.flush()
               __UpperCamelCase       =  BertTokenizerFast(vocab_file.name	)

        with TemporaryDirectory() as bert_save_dir:
               __UpperCamelCase       =  BertModel(BertConfig(vocab_size=len(__A	)	)	)
               model.save_pretrained(__A	)
               self._test_export(__A							,	'pt'							,	1_2							,	__A	)






 @require_tf
 @slow
 def        _lowerCamelCase					(       self       :							List[str]	):
        for model, model_kwargs in OnnxExportTestCase.MODEL_TO_TEST:
               __UpperCamelCase       =  self._test_export(__A							,	'tf'							,	1_2							,	**__A	)
               __UpperCamelCase       =  quantize(Path(__A	)	)

               # Ensure the actual quantized model is not bigger than the original one
               if quantized_path.stat().st_size >= Path(__A	).stat().st_size:
                      self.fail('Quantized model is bigger than initial ONNX model'	)






 @require_torch
 @slow
 def        _lowerCamelCase					(       self       :							int	):
        for model, model_kwargs in OnnxExportTestCase.MODEL_TO_TEST:
               __UpperCamelCase       =  self._test_export(__A							,	'pt'							,	1_2							,	**__A	)
               __UpperCamelCase       =  quantize(__A	)

               # Ensure the actual quantized model is not bigger than the original one
               if quantized_path.stat().st_size >= Path(__A	).stat().st_size:
                      self.fail('Quantized model is bigger than initial ONNX model'	)






 def        _lowerCamelCase					(       self       :							List[str]							,	__A       :							Union[str, Any]							,	__A       :							Any							,	__A       :							str							,	__A       :							Tuple=None							,	**__A       :							Tuple	):
        try:
               # Compute path
               with TemporaryDirectory() as tempdir:
                      __UpperCamelCase       =  Path(__A	).joinpath('model.onnx'	)

               # Remove folder if exists
               if path.parent.exists():
                      path.parent.rmdir()

               # Export
               convert(__A							,	__A							,	__A							,	__A							,	__A							,	**__A	)

               return path
        except Exception as e:
               self.fail(__A	)






 @require_torch
 @require_tokenizers
 @slow
 def        _lowerCamelCase					(       self       :							Optional[Any]	):
        from transformers import BertModel

        __UpperCamelCase       =  BertModel(BertConfig.from_pretrained('lysandre/tiny-bert-random'	)	)
        __UpperCamelCase       =  BertTokenizerFast.from_pretrained('lysandre/tiny-bert-random'	)
        self._test_infer_dynamic_axis(__A							,	__A							,	'pt'	)






 @require_tf
 @require_tokenizers
 @slow
 def        _lowerCamelCase					(       self       :							Optional[Any]	):
        from transformers import TFBertModel

        __UpperCamelCase       =  TFBertModel(BertConfig.from_pretrained('lysandre/tiny-bert-random'	)	)
        __UpperCamelCase       =  BertTokenizerFast.from_pretrained('lysandre/tiny-bert-random'	)
        self._test_infer_dynamic_axis(__A							,	__A							,	'tf'	)






 def        _lowerCamelCase					(       self       :							Tuple							,	__A       :							int							,	__A       :							Optional[int]							,	__A       :							int	):
        __UpperCamelCase       =  FeatureExtractionPipeline(__A							,	__A	)

        __UpperCamelCase       =  ['input_ids', 'token_type_ids', 'attention_mask', 'output_0', 'output_1']
        __UpperCamelCase       ,						__UpperCamelCase       ,						__UpperCamelCase       ,						__UpperCamelCase       =  infer_shapes(__A							,	__A	)

        # Assert all variables are present
        self.assertEqual(len(__A	)							,	len(__A	)	)
        self.assertTrue(all(var_name in shapes for var_name in variable_names	)	)
        self.assertSequenceEqual(variable_names[:3]							,	__A	)
        self.assertSequenceEqual(variable_names[3:]							,	__A	)

        # Assert inputs are {0: batch, 1: sequence}
        for var_name in ["input_ids", "token_type_ids", "attention_mask"]:
               self.assertDictEqual(shapes[var_name]							,	{0: 'batch', 1: 'sequence'}	)

        # Assert outputs are {0: batch, 1: sequence} and {0: batch}
        self.assertDictEqual(shapes['output_0']							,	{0: 'batch', 1: 'sequence'}	)
        self.assertDictEqual(shapes['output_1']							,	{0: 'batch'}	)






 def        _lowerCamelCase					(       self       :							List[Any]	):
        __UpperCamelCase       =  ['input_ids', 'attention_mask', 'token_type_ids']
        __UpperCamelCase       =  {'input_ids': [1, 2, 3, 4], 'attention_mask': [0, 0, 0, 0], 'token_type_ids': [1, 1, 1, 1]}
        __UpperCamelCase       ,						__UpperCamelCase       =  ensure_valid_input(FuncContiguousArgs()							,	__A							,	__A	)

        # Should have exactly the same number of args (all are valid)
        self.assertEqual(len(__A	)							,	3	)

        # Should have exactly the same input names
        self.assertEqual(set(__A	)							,	set(__A	)	)

        # Parameter should be reordered according to their respective place in the function:
        # (input_ids, token_type_ids, attention_mask)
        self.assertEqual(__A							,	(tokens['input_ids'], tokens['token_type_ids'], tokens['attention_mask'])	)

        # Generated args are interleaved with another args (for instance parameter "past" in GPT2)
        __UpperCamelCase       ,						__UpperCamelCase       =  ensure_valid_input(FuncNonContiguousArgs()							,	__A							,	__A	)

        # Should have exactly the one arg (all before the one not provided "some_other_args")
        self.assertEqual(len(__A	)							,	1	)
        self.assertEqual(len(__A	)							,	1	)

        # Should have only "input_ids"
        self.assertEqual(inputs_args[0]							,	tokens['input_ids']	)
        self.assertEqual(ordered_input_names[0]							,	'input_ids'	)






 def        _lowerCamelCase					(       self       :							Any	):
        __UpperCamelCase       =  generate_identified_filename(Path('/home/something/my_fake_model.onnx'	)							,	'-test'	)
        self.assertEqual('/home/something/my_fake_model-test.onnx'							,	generated.as_posix()	)

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

            return sequence[n]


def    a__       (						__UpperCamelCase ):
      SCREAMING_SNAKE_CASE_      =     0
      SCREAMING_SNAKE_CASE_      =     2

      while digits < n:
            index += 1
            SCREAMING_SNAKE_CASE_      =     len(str(fibonacci(__UpperCamelCase ) ) )

      return index


def    a__       (						__UpperCamelCase = 1_0_0_0 ):
      return fibonacci_digits_index(__UpperCamelCase )


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


