


"""simple docstring"""




import warnings
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 					__lowerCAmelCase					(   __SCREAMING_SNAKE_CASE       ):


		'''simple docstring'''



		__UpperCAmelCase		:			Union[str, Any]										=				['image_processor', 'tokenizer']
		__UpperCAmelCase		:			int										=				'LayoutLMv3ImageProcessor'
		__UpperCAmelCase		:			List[str]										=				('LayoutLMv3Tokenizer', 'LayoutLMv3TokenizerFast')

		def __init__(  self							, _a=None							, _a=None							, **_a      ):
				__a           =			None
				if "feature_extractor" in kwargs:
						warnings.warn(
						    '''The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`'''
						    ''' instead.'''							, _a							, )
						__a           =			kwargs.pop('''feature_extractor'''      )

				__a           =			image_processor if image_processor is not None else feature_extractor
				if image_processor is None:
						raise ValueError('''You need to specify an `image_processor`.'''      )
				if tokenizer is None:
						raise ValueError('''You need to specify a `tokenizer`.'''      )

				super().__init__(_a							, _a      )

		def __call__(  self							, _a							, _a = None							, _a = None							, _a = None							, _a = None							, _a = True							, _a = False							, _a = None							, _a = None							, _a = 0							, _a = None							, _a = None							, _a = None							, _a = False							, _a = False							, _a = False							, _a = False							, _a = True							, _a = None							, **_a							, ):
				# verify input
				if self.image_processor.apply_ocr and (boxes is not None):
						raise ValueError(
						    '''You cannot provide bounding boxes if you initialized the image processor with apply_ocr set to True.'''      )

				if self.image_processor.apply_ocr and (word_labels is not None):
						raise ValueError(
						    '''You cannot provide word labels if you initialized the image processor with apply_ocr set to True.'''      )

				# first, apply the image processor
				__a           =			self.image_processor(images=_a							, return_tensors=_a      )

				# second, apply the tokenizer
				if text is not None and self.image_processor.apply_ocr and text_pair is None:
						if isinstance(_a							, _a      ):
								__a           =			[text]  # add batch dimension (as the image processor always adds a batch dimension)
						__a           =			features['''words''']

				__a           =			self.tokenizer(
				    text=text if text is not None else features['''words''']							, text_pair=text_pair if text_pair is not None else None							, boxes=boxes if boxes is not None else features['''boxes''']							, word_labels=_a							, add_special_tokens=_a							, padding=_a							, truncation=_a							, max_length=_a							, stride=_a							, pad_to_multiple_of=_a							, return_token_type_ids=_a							, return_attention_mask=_a							, return_overflowing_tokens=_a							, return_special_tokens_mask=_a							, return_offsets_mapping=_a							, return_length=_a							, verbose=_a							, return_tensors=_a							, **_a							, )

				# add pixel values
				__a           =			features.pop('''pixel_values'''      )
				if return_overflowing_tokens is True:
						__a           =			self.get_overflowing_images(_a							, encoded_inputs['''overflow_to_sample_mapping''']      )
				__a           =			images

				return encoded_inputs

		def 			__UpperCAmelCase       (  self							, _a							, _a      ):
				# in case there's an overflow, ensure each `input_ids` sample is mapped to its corresponding image
				__a           =			[]
				for sample_idx in overflow_to_sample_mapping:
						images_with_overflow.append(images[sample_idx]      )

				if len(_a      ) != len(_a      ):
						raise ValueError(
						    '''Expected length of images to be the same as the length of `overflow_to_sample_mapping`, but got'''
						    f''' {len(_a      )} and {len(_a      )}'''      )

				return images_with_overflow

		def 			__UpperCAmelCase       (  self							, *_a							, **_a      ):
				return self.tokenizer.batch_decode(*_a							, **_a      )

		def 			__UpperCAmelCase       (  self							, *_a							, **_a      ):
				return self.tokenizer.decode(*_a							, **_a      )

		@property
		def 			__UpperCAmelCase       (  self      ):
				return ["input_ids", "bbox", "attention_mask", "pixel_values"]

		@property
		def 			__UpperCAmelCase       (  self      ):
				warnings.warn(
				    '''`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead.'''							, _a							, )
				return self.image_processor_class





		@property
		def 			__UpperCAmelCase       (  self      ):
				warnings.warn(
				    '''`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead.'''							, _a							, )
				return self.image_processor







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