def 							UpperCAmelCase		(       lowercase				,     lowercase				):







				"""simple docstring"""



				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 							UpperCAmelCase		(       lowercase				,     lowercase				):







				"""simple docstring"""



				__lowercase					     =				[[float('''inf'''				) for _ in range(lowercase				)] for _ in range(lowercase				)]

				for i in range(lowercase				):
								for j in range(lowercase				):
												__lowercase					     =				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]
																):
																				__lowercase					     =				dist[i][k] + dist[k][j]

				_print_dist(lowercase				,     lowercase				)
				return dist, v


if __name__ == "__main__":
		__a    :	List[str]         =    int(input("""Enter number of vertices: """))
		__a    :	List[Any]         =    int(input("""Enter number of edges: """))

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

		for i in range(v):
				__a    :	Union[str, Any]         =    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)
				__a    :	Dict         =    int(input("""Enter source:"""))
				__a    :	List[str]         =    int(input("""Enter destination:"""))
				__a    :	Optional[int]         =    float(input("""Enter weight:"""))
				__a    :	Optional[Any]         =    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 ...configuration_utils import PretrainedConfig
from ...utils import logging


__a    :	int         =    logging.get_logger(__name__)

__a    :	Optional[int]         =    {
    """google/pegasus-large""": """https://huggingface.co/google/pegasus-large/resolve/main/config.json""",
    # See all PEGASUS models at https://huggingface.co/models?filter=pegasus
}




class   _UpperCamelCase (		_UpperCAmelCase					):


			"""simple docstring"""






			__a    :					Any     					=		'''pegasus'''
			__a    :					Optional[Any]     					=		['''past_key_values''']
			__a    :					Tuple     					=		{'''num_attention_heads''': '''encoder_attention_heads''', '''hidden_size''': '''d_model'''}





			def __init__(  self ,  lowerCAmelCase__=5_02_65 ,  lowerCAmelCase__=10_24 ,  lowerCAmelCase__=12 ,  lowerCAmelCase__=40_96 ,  lowerCAmelCase__=16 ,  lowerCAmelCase__=12 ,  lowerCAmelCase__=40_96 ,  lowerCAmelCase__=16 ,  lowerCAmelCase__=0.0 ,  lowerCAmelCase__=0.0 ,  lowerCAmelCase__=True ,  lowerCAmelCase__=True ,  lowerCAmelCase__="gelu" ,  lowerCAmelCase__=10_24 ,  lowerCAmelCase__=0.1 ,  lowerCAmelCase__=0.0 ,  lowerCAmelCase__=0.0 ,  lowerCAmelCase__=0.02 ,  lowerCAmelCase__=0 ,  lowerCAmelCase__=False ,  lowerCAmelCase__=0 ,  lowerCAmelCase__=1 ,  lowerCAmelCase__=1 ,  **lowerCAmelCase__ ,  )	->   Dict:

							'''simple docstring'''


							__lowercase					     =				vocab_size
							__lowercase					     =				max_position_embeddings
							__lowercase					     =				d_model
							__lowercase					     =				encoder_ffn_dim
							__lowercase					     =				encoder_layers
							__lowercase					     =				encoder_attention_heads
							__lowercase					     =				decoder_ffn_dim
							__lowercase					     =				decoder_layers
							__lowercase					     =				decoder_attention_heads
							__lowercase					     =				dropout
							__lowercase					     =				attention_dropout
							__lowercase					     =				activation_dropout
							__lowercase					     =				activation_function
							__lowercase					     =				init_std
							__lowercase					     =				encoder_layerdrop
							__lowercase					     =				decoder_layerdrop
							__lowercase					     =				use_cache
							__lowercase					     =				encoder_layers
							__lowercase					     =				scale_embedding  # scale factor will be sqrt(d_model) if True
							super().__init__(
							    pad_token_id=lowerCAmelCase__ ,  eos_token_id=lowerCAmelCase__ ,  is_encoder_decoder=lowerCAmelCase__ ,  decoder_start_token_id=lowerCAmelCase__ ,  forced_eos_token_id=lowerCAmelCase__ ,  **lowerCAmelCase__ ,  )





			@property
			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   int:

							'''simple docstring'''


							return self.encoder_attention_heads





			@property
			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   int:

							'''simple docstring'''


							return self.d_model