



"""simple docstring"""






from __future__ import annotations






def        snake_case_  (      A_					:		Optional[Any],				A_					:		Optional[int]						):


       '''simple docstring'''





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






def        snake_case_  (      A_					:		int,				A_					:		Dict,				A_					:		Optional[int]						):


       '''simple docstring'''





       for j in range(__UpperCamelCase						):
              _lowerCamelCase			,    _lowerCamelCase			,    _lowerCamelCase						:				Tuple    			= (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        snake_case_  (      A_					:		Dict,				A_					:		Tuple,				A_					:		Optional[Any],				A_					:		List[str]						):


       '''simple docstring'''





       _lowerCamelCase						:				List[str]    			= [float('''inf'''						)] * vertex_count
       _lowerCamelCase						:				Dict    			= 0.0

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

                     if distance[u] != float('''inf'''						) and distance[u] + w < distance[v]:
                            _lowerCamelCase						:				List[str]    			= distance[u] + w

       _lowerCamelCase						:				Dict    			= check_negative_cycle(__UpperCamelCase,				__UpperCamelCase,				__UpperCamelCase						)
       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    a__       (						__UpperCamelCase ):
      if n == 1 or not isinstance(__UpperCamelCase   ,					__UpperCamelCase ):
            return 0
      elif n == 2:
            return 1
      else:
            SCREAMING_SNAKE_CASE_      =     [0, 1]
            for i in range(2   ,					n + 1 ):
                  sequence.append(sequence[i - 1] + sequence[i - 2] )

            return sequence[n]


def    a__       (						__UpperCamelCase ):
      SCREAMING_SNAKE_CASE_      =     0
      SCREAMING_SNAKE_CASE_      =     2

      while digits < n:
            index += 1
            SCREAMING_SNAKE_CASE_      =     len(str(fibonacci(__UpperCamelCase ) ) )

      return index


def    a__       (						__UpperCamelCase = 1_0_0_0 ):
      return fibonacci_digits_index(__UpperCamelCase )


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


