



from __future__ import annotations


def    __lowerCamelCase   (  lowerCamelCase__	,					lowerCamelCase__		):

				"""simple docstring"""


				print(F"""Vertex\tShortest Distance from vertex {src}"""		)
				for i, d in enumerate(lowerCamelCase_		):
								print(F"""{i}\t\t{d}"""		)


def    __lowerCamelCase   (  lowerCamelCase__	,					lowerCamelCase__	,					lowerCamelCase__		):

				"""simple docstring"""


				for j in range(lowerCamelCase_		):
								lowercase__	:       Dict						=	(graph[j][k] for k in ['src', 'dst', 'weight'])
								if distance[u] != float("inf"		) and distance[u] + w < distance[v]:
												return True
				return False


def    __lowerCamelCase   (  lowerCamelCase__	,					lowerCamelCase__	,					lowerCamelCase__	,					lowerCamelCase__		):

				"""simple docstring"""


				lowercase__	:       Optional[int]						=	[float("inf"		)] * vertex_count
				lowercase__	:       str						=	0.0

				for _ in range(vertex_count - 1		):
								for j in range(lowerCamelCase_		):
												lowercase__	:       Any						=	(graph[j][k] for k in ['src', 'dst', 'weight'])

												if distance[u] != float("inf"		) and distance[u] + w < distance[v]:
																lowercase__	:       int						=	distance[u] + w

				lowercase__	:       Dict						=	check_negative_cycle(lowerCamelCase_	,					lowerCamelCase_	,					lowerCamelCase_		)
				if negative_cycle_exists:
								raise Exception("Negative cycle found"		)

				return distance


if __name__ == "__main__":
				import doctest

				doctest.testmod()

				lowerCAmelCase__	    =    int(input('''Enter number of vertices: ''').strip())
				lowerCAmelCase__	    =    int(input('''Enter number of edges: ''').strip())

				lowerCAmelCase__	    =    [{} for _ in range(E)]

				for i in range(E):
								print('''Edge ''', i + 1)
								lowerCAmelCase__	    =    (
								    int(x)
								    for x in input('''Enter source, destination, weight: ''').strip().split(''' ''')
								)
								lowerCAmelCase__	    =    {"src": src, "dst": dest, "weight": weight}

				lowerCAmelCase__	    =    int(input('''\nEnter shortest path source:''').strip())
				lowerCAmelCase__	    =    bellman_ford(graph, V, E, source)
				print_distance(shortest_distance, 0)








def 							UpperCamelCase_( lowerCamelCase_					)       ->		int:
    if n == 1 or not isinstance(lowerCamelCase_				,					lowerCamelCase_					):
        return 0
    elif n == 2:
        return 1
    else:
        _lowercase			:				List[str] 						=						[0, 1]
        for i in range(2				,					n + 1					):
            sequence.append(sequence[i - 1] + sequence[i - 2]					)

        return sequence[n]



def 							UpperCamelCase_( lowerCamelCase_					)       ->		int:
    _lowercase			:				Tuple 						=						0
    _lowercase			:				List[str] 						=						2

    while digits < n:
        index += 1
        _lowercase			:				Optional[int] 						=						len(str(fibonacci(lowerCamelCase_					)					)					)

    return index



def 							UpperCamelCase_( lowerCamelCase_ = 1000					)       ->		int:
    return fibonacci_digits_index(lowerCamelCase_					)


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


