
def      UpperCamelCase   (       __lowerCamelCase	:					Dict							,   __lowerCamelCase	:					Dict       ):
       print("\nThe shortest path matrix using Floyd Warshall algorithm\n"       )
       for i in range(_UpperCAmelCase       ):
              for j in range(_UpperCAmelCase       ):
                     if dist[i][j] != float("inf"       ):
                            print(int(dist[i][j]       )							,   end="\t"       )
                     else:
                            print("INF"							,   end="\t"       )
              print()


def      UpperCamelCase   (       __lowerCamelCase	:					int							,   __lowerCamelCase	:					Union[str, Any]       ):
       snake_case			:  Dict     							= [[float("inf"       ) for _ in range(_UpperCAmelCase       )] for _ in range(_UpperCAmelCase       )]

       for i in range(_UpperCAmelCase       ):
              for j in range(_UpperCAmelCase       ):
                     snake_case			:  Any     							= graph[i][j]

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

       _print_dist(_UpperCAmelCase							,   _UpperCAmelCase       )
       return dist, v


if __name__ == "__main__":
   __lowerCamelCase				=			int(input("""Enter number of vertices: """))
   __lowerCamelCase				=			int(input("""Enter number of edges: """))

   __lowerCamelCase				=			[[float("""inf""") for i in range(v)] for j in range(v)]

   for i in range(v):
      __lowerCamelCase				=			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)
      __lowerCamelCase				=			int(input("""Enter source:"""))
      __lowerCamelCase				=			int(input("""Enter destination:"""))
      __lowerCamelCase				=			float(input("""Enter weight:"""))
      __lowerCamelCase				=			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 __future__ import annotations

import unittest

from transformers import is_tf_available
from transformers.testing_utils import require_sentencepiece, require_tf, require_tokenizers, slow


if is_tf_available():
    import tensorflow as tf

    from transformers import AutoTokenizer, TFAutoModelForSeqaSeqLM

@require_tf
@require_sentencepiece
@require_tokenizers
class   lowerCAmelCase				(   unittest.TestCase     ):
 @slow
 def 	A_      ( self    : int      )     ->      Optional[Any]:
     lowerCamelCase__       : Tuple   					=						TFAutoModelForSeqaSeqLM.from_pretrained('google/mt5-small'      )
     lowerCamelCase__       : Any   					=						AutoTokenizer.from_pretrained('google/mt5-small'      )

     lowerCamelCase__       : int   					=						tokenizer('Hello there'     ,	return_tensors='tf'      ).input_ids
     lowerCamelCase__       : int   					=						tokenizer('Hi I am'     ,	return_tensors='tf'      ).input_ids

     lowerCamelCase__       : List[str]   					=						model(UpperCAmelCase     ,	labels=UpperCAmelCase      ).loss
     lowerCamelCase__       : List[Any]   					=						-tf.math.reduce_mean(UpperCAmelCase      ).numpy()

     lowerCamelCase__       : Dict   					=						-2_1.2_2_8_1_6_8
     self.assertTrue(abs(mtf_score - EXPECTED_SCORE      ) < 2e-4      )





