





from typing import List, Optional, Union

from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding, PaddingStrategy, PreTokenizedInput, TextInput, TruncationStrategy
from ...utils import TensorType



class  A__       (	__snake_case      ):
      _UpperCAmelCase     :List[Any]						   =       ['image_processor', 'tokenizer']
      _UpperCAmelCase     :List[str]						   =       'Pix2StructImageProcessor'
      _UpperCAmelCase     :Optional[int]						   =       ('T5Tokenizer', 'T5TokenizerFast')





      def __init__(			self	,							A_	,							A_       ):
       '''simple docstring'''




       UpperCamelCase     : Union[str, Any]	     =       False
       super().__init__(A_	,							A_       )





      def __call__(			self	,							A_=None	,							A_ = None	,							A_ = True	,							A_ = False	,							A_ = None	,							A_ = None	,							A_ = 2048	,							A_ = 0	,							A_ = None	,							A_ = None	,							A_ = False	,							A_ = False	,							A_ = False	,							A_ = False	,							A_ = False	,							A_ = True	,							A_ = None	,							**A_	,							):
       '''simple docstring'''




       if images is None and text is None:
        raise ValueError("You have to specify either images or text."       )

       # Get only text
       if images is None and not self.image_processor.is_vqa:
        UpperCamelCase     : Dict	     =       self.tokenizer
        UpperCamelCase     : List[str]	     =       self.tokenizer(
            text=A_	,							add_special_tokens=A_	,							padding=A_	,							truncation=A_	,							max_length=A_	,							stride=A_	,							pad_to_multiple_of=A_	,							return_attention_mask=A_	,							return_overflowing_tokens=A_	,							return_special_tokens_mask=A_	,							return_offsets_mapping=A_	,							return_token_type_ids=A_	,							return_length=A_	,							verbose=A_	,							return_tensors=A_	,							**A_	,							)
        return text_encoding

       if not self.image_processor.is_vqa:
        # add pixel_values
        UpperCamelCase     : Dict	     =       self.image_processor(
            A_	,							return_tensors=A_	,							max_patches=A_	,							**A_       )
       else:
        # add pixel_values and bbox
        UpperCamelCase     : str	     =       self.image_processor(
            A_	,							return_tensors=A_	,							max_patches=A_	,							header_text=A_	,							**A_       )

       if text is not None and not self.image_processor.is_vqa:
        UpperCamelCase     : int	     =       self.tokenizer(
            text=A_	,							add_special_tokens=A_	,							padding=A_	,							truncation=A_	,							max_length=A_	,							stride=A_	,							pad_to_multiple_of=A_	,							return_attention_mask=A_	,							return_overflowing_tokens=A_	,							return_special_tokens_mask=A_	,							return_offsets_mapping=A_	,							return_token_type_ids=A_	,							return_length=A_	,							verbose=A_	,							return_tensors=A_	,							**A_	,							)

        if "attention_mask" in text_encoding:
         UpperCamelCase     : Any	     =       text_encoding.pop("attention_mask"       )
        if "input_ids" in text_encoding:
         UpperCamelCase     : Any	     =       text_encoding.pop("input_ids"       )
       else:
        UpperCamelCase     : Optional[int]	     =       None

       if text_encoding is not None:
        encoding_image_processor.update(A_       )

       return encoding_image_processor





      def 	__UpperCamelCase(			self	,							*A_	,							**A_       ):
       '''simple docstring'''




       return self.tokenizer.batch_decode(*A_	,							**A_       )





      def 	__UpperCamelCase(			self	,							*A_	,							**A_       ):
       '''simple docstring'''




       return self.tokenizer.decode(*A_	,							**A_       )





      @property
      def 	__UpperCamelCase(			self       ):
       '''simple docstring'''




       UpperCamelCase     : List[str]	     =       self.tokenizer.model_input_names
       UpperCamelCase     : Optional[int]	     =       self.image_processor.model_input_names
       return list(dict.fromkeys(tokenizer_input_names + image_processor_input_names       )       )







def 		A_    (					_lowerCAmelCase					)						->			int:
 if n == 1 or not isinstance(_lowerCAmelCase							,       _lowerCAmelCase					):
  return 0
 elif n == 2:
  return 1
 else:
  UpperCamelCase     : Optional[Any]	     =       [0, 1]
  for i in range(2							,       n + 1					):
   sequence.append(sequence[i - 1] + sequence[i - 2]					)

  return sequence[n]



def 		A_    (					_lowerCAmelCase					)						->			int:
 UpperCamelCase     : Any	     =       0
 UpperCamelCase     : List[Any]	     =       2

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

 return index



def 		A_    (					_lowerCAmelCase = 1000					)						->			int:
 return fibonacci_digits_index(_lowerCAmelCase					)


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