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







def 			A__      (	snake_case_ :		List[Any]       ,				snake_case_ :		str      ):
 SCREAMING_SNAKE_CASE__:   Any=      [[float('''inf'''      ) for _ in range(snake_case_      )] for _ in range(snake_case_      )]

 for i in range(snake_case_      ):
  for j in range(snake_case_      ):
   SCREAMING_SNAKE_CASE__:   List[Any]=      graph[i][j]

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

 _print_dist(snake_case_       ,				snake_case_      )
 return dist, v


if __name__ == "__main__":
      lowercase_     :   Any 				=				int(input('Enter number of vertices: '))
      lowercase_     :   Optional[int] 				=				int(input('Enter number of edges: '))

      lowercase_     :   List[str] 				=				[[float('inf') for i in range(v)] for j in range(v)]

      for i in range(v):
            lowercase_     :   Tuple 				=				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)
            lowercase_     :   Tuple 				=				int(input('Enter source:'))
            lowercase_     :   Optional[int] 				=				int(input('Enter destination:'))
            lowercase_     :   Dict 				=				float(input('Enter weight:'))
            lowercase_     :   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 collections import OrderedDict
from typing import Mapping

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


lowercase_     :   List[Any] 				=				logging.get_logger(__name__)

lowercase_     :   List[Any] 				=				{
    'facebook/xlm-roberta-xl': 'https://huggingface.co/facebook/xlm-roberta-xl/resolve/main/config.json',
    'facebook/xlm-roberta-xxl': 'https://huggingface.co/facebook/xlm-roberta-xxl/resolve/main/config.json',
    # See all XLM-RoBERTa-XL models at https://huggingface.co/models?filter=xlm-roberta-xl
}






class 		_lowerCamelCase		(   UpperCamelCase_    ):
    __a  =      "xlm-roberta-xl"
    def __init__(  self , lowerCAmelCase=250880 , lowerCAmelCase=2560 , lowerCAmelCase=36 , lowerCAmelCase=32 , lowerCAmelCase=10240 , lowerCAmelCase="gelu" , lowerCAmelCase=0.1 , lowerCAmelCase=0.1 , lowerCAmelCase=514 , lowerCAmelCase=1 , lowerCAmelCase=0.02 , lowerCAmelCase=1e-05 , lowerCAmelCase=1 , lowerCAmelCase=0 , lowerCAmelCase=2 , lowerCAmelCase="absolute" , lowerCAmelCase=True , lowerCAmelCase=None , **lowerCAmelCase , )       ->					Union[str, Any]:
     super().__init__(pad_token_id=lowerCAmelCase , bos_token_id=lowerCAmelCase , eos_token_id=lowerCAmelCase , **lowerCAmelCase   )
     SCREAMING_SNAKE_CASE__:   List[Any]=      vocab_size
     SCREAMING_SNAKE_CASE__:   Dict=      hidden_size
     SCREAMING_SNAKE_CASE__:   Tuple=      num_hidden_layers
     SCREAMING_SNAKE_CASE__:   Optional[Any]=      num_attention_heads
     SCREAMING_SNAKE_CASE__:   int=      hidden_act
     SCREAMING_SNAKE_CASE__:   Any=      intermediate_size
     SCREAMING_SNAKE_CASE__:   Optional[Any]=      hidden_dropout_prob
     SCREAMING_SNAKE_CASE__:   str=      attention_probs_dropout_prob
     SCREAMING_SNAKE_CASE__:   List[Any]=      max_position_embeddings
     SCREAMING_SNAKE_CASE__:   Dict=      type_vocab_size
     SCREAMING_SNAKE_CASE__:   Union[str, Any]=      initializer_range
     SCREAMING_SNAKE_CASE__:   Dict=      layer_norm_eps
     SCREAMING_SNAKE_CASE__:   Dict=      position_embedding_type
     SCREAMING_SNAKE_CASE__:   Optional[Any]=      use_cache
     SCREAMING_SNAKE_CASE__:   str=      classifier_dropout






class 		_lowerCamelCase		(   UpperCamelCase_    ):
    @property
    def 						UpperCamelCase_				(  self   )       ->					Mapping[str, Mapping[int, str]]:
     if self.task == "multiple-choice":
      SCREAMING_SNAKE_CASE__:   Dict=      {0: '''batch''', 1: '''choice''', 2: '''sequence'''}
     else:
      SCREAMING_SNAKE_CASE__:   List[str]=      {0: '''batch''', 1: '''sequence'''}
     return OrderedDict(
         [
             ('''input_ids''', dynamic_axis),
             ('''attention_mask''', dynamic_axis),
         ]   )

