




'''simple docstring'''


import argparse
import os
import re


_snake_case   :   Tuple     							=	'src/transformers/models/auto'


# re pattern that matches mapping introductions:
#    SUPER_MODEL_MAPPING_NAMES = OrderedDict or SUPER_MODEL_MAPPING = OrderedDict
_snake_case   :   str     							=	re.compile(R'[A-Z_]+_MAPPING(\s+|_[A-Z_]+\s+)=\s+OrderedDict')
# re pattern that matches identifiers in mappings
_snake_case   :   Tuple     							=	re.compile(R'\s*\(\s*"(\S[^"]+)"')
def 	snake_case_					(UpperCamelCase :						Optional[int]				,		UpperCamelCase :						bool = False   ):





							'''simple docstring'''


							with open(UpperCamelCase				,		'''r'''				,		encoding='''utf-8'''   ) as f:
														_a			  =       f.read()

							_a			  =       content.split('''\n'''   )
							_a			  =       []
							_a			  =       0
							while line_idx < len(UpperCamelCase   ):
														if _re_intro_mapping.search(lines[line_idx]   ) is not None:
																					_a			  =       len(re.search(R'''^(\s*)\S'''				,		lines[line_idx]   ).groups()[0]   ) + 8
																					# Start of a new mapping!
																					while not lines[line_idx].startswith(''' ''' * indent + '''('''   ):
																												new_lines.append(lines[line_idx]   )
																												line_idx += 1

																					_a			  =       []
																					while lines[line_idx].strip() != "]":
																												# Blocks either fit in one line or not
																												if lines[line_idx].strip() == "(":
																																			_a			  =       line_idx
																																			while not lines[line_idx].startswith(''' ''' * indent + ''')'''   ):
																																										line_idx += 1
																																			blocks.append('''\n'''.join(lines[start_idx : line_idx + 1]   )   )
																												else:
																																			blocks.append(lines[line_idx]   )
																												line_idx += 1

																					# Sort blocks by their identifiers
																					_a			  =       sorted(UpperCamelCase				,		key=lambda UpperCamelCase   : _re_identifier.search(UpperCamelCase   ).groups()[0]   )
																					new_lines += blocks
														else:
																					new_lines.append(lines[line_idx]   )
																					line_idx += 1

							if overwrite:
														with open(UpperCamelCase				,		'''w'''				,		encoding='''utf-8'''   ) as f:
																					f.write('''\n'''.join(UpperCamelCase   )   )
							elif "\n".join(UpperCamelCase   ) != content:
														return True
def 	snake_case_					(UpperCamelCase :						bool = False   ):





							'''simple docstring'''


							_a			  =       [os.path.join(UpperCamelCase				,		UpperCamelCase   ) for f in os.listdir(UpperCamelCase   ) if f.endswith('''.py'''   )]
							_a			  =       [sort_auto_mapping(UpperCamelCase				,		overwrite=UpperCamelCase   ) for fname in fnames]

							if not overwrite and any(UpperCamelCase   ):
														_a			  =       [f for f, d in zip(UpperCamelCase				,		UpperCamelCase   ) if d]
														raise ValueError(
														    f'The following files have auto mappings that need sorting: {", ".join(UpperCamelCase   )}. Run `make style` to fix'
														    ''' this.'''   )


if __name__ == "__main__":
				_snake_case   :   Optional[int]     							=	argparse.ArgumentParser()
				parser.add_argument('--check_only', action='store_true', help='Whether to only check or fix style.')
				_snake_case   :   Optional[int]     							=	parser.parse_args()

				sort_all_auto_mappings(not args.check_only)







'''simple docstring'''


def 	snake_case_					(UpperCamelCase :						int   ):





							'''simple docstring'''


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

														return sequence[n]
def 	snake_case_					(UpperCamelCase :						int   ):





							'''simple docstring'''


							_a			  =       0
							_a			  =       2

							while digits < n:
														index += 1
														_a			  =       len(str(fibonacci(UpperCamelCase   )   )   )

							return index
def 	snake_case_					(UpperCamelCase :						int = 1000   ):





							'''simple docstring'''


							return fibonacci_digits_index(UpperCamelCase   )


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

