



def 		lowerCAmelCase__     (       UpperCamelCase_					:							int						)->	int:
    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 		lowerCAmelCase__     (       UpperCamelCase_					:							int						)->	int:
    A__					=       0
    A__					=       2

    while digits < n:
        index += 1
        A__					=       len(str(fibonacci(UpperCamelCase_						)						)						)

    return index



def 		lowerCAmelCase__     (       UpperCamelCase_					:							int = 1_0_0_0						)->	int:
    return fibonacci_digits_index(UpperCamelCase_						)


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





from __future__ import annotations



def 		lowerCAmelCase__     (       UpperCamelCase_					:							dict			,							UpperCamelCase_					:							str						)->	set[str]:
    A__			,						A__					=       set(UpperCamelCase_						), [start]

    while stack:
        A__					=       stack.pop()
        explored.add(UpperCamelCase_						)
        # Differences from BFS:
        # 1) pop last element instead of first one
        # 2) add adjacent elements to stack without exploring them
        for adj in reversed(graph[v]						):
            if adj not in explored:
                stack.append(UpperCamelCase_						)
    return explored


_lowercase    	=		{
    "A": ["B", "C", "D"],
    "B": ["A", "D", "E"],
    "C": ["A", "F"],
    "D": ["B", "D"],
    "E": ["B", "F"],
    "F": ["C", "E", "G"],
    "G": ["F"],
}

if __name__ == "__main__":
   import doctest

   doctest.testmod()
   print(depth_first_search(G, "A"))
