


def      snake_case_						( __lowercase			,       __lowercase       ):
   print('''\nThe shortest path matrix using Floyd Warshall algorithm\n'''       )
   for i in range(__lowercase       ):
      for j in range(__lowercase       ):
         if dist[i][j] != float('''inf'''       ):
            print(int(dist[i][j]       )			,       end='''\t'''       )
         else:
            print('''INF'''			,       end='''\t'''       )
      print()
def      snake_case_						( __lowercase			,       __lowercase       ):
   UpperCAmelCase_							:      str						=   [[float('''inf'''       ) for _ in range(__lowercase       )] for _ in range(__lowercase       )]

   for i in range(__lowercase       ):
      for j in range(__lowercase       ):
         UpperCAmelCase_							:      Optional[Any]						=   graph[i][j]

         # check vertex k against all other vertices (i, j)
   for k in range(__lowercase       ):
      # looping through rows of graph array
      for i in range(__lowercase       ):
         # looping through columns of graph array
         for j in range(__lowercase       ):
            if (
                dist[i][k] != float('''inf'''       )
                and dist[k][j] != float('''inf'''       )
                and dist[i][k] + dist[k][j] < dist[i][j]
            ):
               UpperCAmelCase_							:      int						=   dist[i][k] + dist[k][j]

   _print_dist(__lowercase			,       __lowercase       )
   return dist, v


if __name__ == "__main__":
       __UpperCamelCase				:  Dict      					=							int(input('Enter number of vertices: '))
       __UpperCamelCase				:  Any      					=							int(input('Enter number of edges: '))

       __UpperCamelCase				:  Optional[Any]      					=							[[float('inf') for i in range(v)] for j in range(v)]

       for i in range(v):
              __UpperCamelCase				:  str      					=							0.0

              # src and dst are indices that must be within the array size graph[e][v]
              # failure to follow this will result in an error
       for i in range(e):
              print('\nEdge ', i + 1)
              __UpperCamelCase				:  List[str]      					=							int(input('Enter source:'))
              __UpperCamelCase				:  str      					=							int(input('Enter destination:'))
              __UpperCamelCase				:  List[Any]      					=							float(input('Enter weight:'))
              __UpperCamelCase				:  Tuple      					=							weight

       floyd_warshall(graph, v)

       # Example Input
       # Enter number of vertices: 3
       # Enter number of edges: 2

       # # generated graph from vertex and edge inputs
       # [[inf, inf, inf], [inf, inf, inf], [inf, inf, inf]]
       # [[0.0, inf, inf], [inf, 0.0, inf], [inf, inf, 0.0]]

       # specify source, destination and weight for edge #1
       # Edge  1
       # Enter source:1
       # Enter destination:2
       # Enter weight:2

       # specify source, destination and weight for edge #2
       # Edge  2
       # Enter source:2
       # Enter destination:1
       # Enter weight:1

       # # Expected Output from the vertice, edge and src, dst, weight inputs!!
       # 0		INF	INF
       # INF	0	2
       # INF	1	0



from transformers import HfArgumentParser, TensorFlowBenchmark, TensorFlowBenchmarkArguments
def      snake_case_						( ):
   UpperCAmelCase_							:      str						=   HfArgumentParser(__lowercase       )
   UpperCAmelCase_							:      Optional[Any]						=   parser.parse_args_into_dataclasses()[0]
   UpperCAmelCase_							:      Optional[int]						=   TensorFlowBenchmark(args=__lowercase       )
   try:
      UpperCAmelCase_							:      List[Any]						=   parser.parse_args_into_dataclasses()[0]
   except ValueError as e:
      UpperCAmelCase_							:      List[Any]						=   '''Arg --no_{0} is no longer used, please use --no-{0} instead.'''
      UpperCAmelCase_							:      List[str]						=   ''' '''.join(str(__lowercase       ).split(''' '''       )[:-1]       )
      UpperCAmelCase_							:      Optional[int]						=   ''''''
      UpperCAmelCase_							:      Dict						=   eval(str(__lowercase       ).split(''' '''       )[-1]       )
      UpperCAmelCase_							:      int						=   []
      for arg in depreciated_args:
         # arg[2:] removes '--'
         if arg[2:] in TensorFlowBenchmark.deprecated_args:
            # arg[5:] removes '--no_'
            full_error_msg += arg_error_msg.format(arg[5:]       )
         else:
            wrong_args.append(__lowercase       )
      if len(__lowercase       ) > 0:
         UpperCAmelCase_							:      Tuple						=   full_error_msg + begin_error_msg + str(__lowercase       )
      raise ValueError(__lowercase       )
   benchmark.run()


if __name__ == "__main__":
       main()