

'''simple docstring'''

import argparse
import os
import re


UpperCAmelCase					 =	'''src/transformers/models/auto'''


# re pattern that matches mapping introductions:
#    SUPER_MODEL_MAPPING_NAMES = OrderedDict or SUPER_MODEL_MAPPING = OrderedDict
UpperCAmelCase					 =	re.compile(r'''[A-Z_]+_MAPPING(\s+|_[A-Z_]+\s+)=\s+OrderedDict''')
# re pattern that matches identifiers in mappings
UpperCAmelCase					 =	re.compile(r'''\s*\(\s*"(\S[^"]+)"''')

def 					__UpperCamelCase				(						lowercase__    :	List[Any],       lowercase__    :	bool = False			):






     '''simple docstring'''





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

     __lowercase      		=content.split('\n'			)
     __lowercase      		=[]
     __lowercase      		=0
     while line_idx < len(lowercase__			):
          if _re_intro_mapping.search(lines[line_idx]			) is not None:
               __lowercase      		=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

               __lowercase      		=[]
               while lines[line_idx].strip() != "]":
                    # Blocks either fit in one line or not
                    if lines[line_idx].strip() == "(":
                         __lowercase      		=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
               __lowercase      		=sorted(lowercase__,       key=lambda lowercase__			: _re_identifier.search(lowercase__			).groups()[0]			)
               new_lines += blocks
          else:
               new_lines.append(lines[line_idx]			)
               line_idx += 1

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

def 					__UpperCamelCase				(						lowercase__    :	bool = False			):






     '''simple docstring'''





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

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


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

       sort_all_auto_mappings(not args.check_only)





'''simple docstring'''

def 					__UpperCamelCase				(						lowercase__    :	int			):






     '''simple docstring'''





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

          return sequence[n]

def 					__UpperCamelCase				(						lowercase__    :	int			):






     '''simple docstring'''





     __lowercase      		=0
     __lowercase      		=2

     while digits < n:
          index += 1
          __lowercase      		=len(str(fibonacci(lowercase__			)			)			)

     return index

def 					__UpperCamelCase				(						lowercase__    :	int = 10_00			):






     '''simple docstring'''





     return fibonacci_digits_index(lowercase__			)


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


