




import math
class 						_A :






  def __init__(  self		:     List[Any]				,						_A		:     Tuple=0				)		->   List[Any]:  # a graph with Node 0,1,...,N-1






       """simple docstring"""







       lowercase :       Any       =			n
       lowercase :       Any       =			[
           [math.inf for j in range(0				,						_A				)] for i in range(0				,						_A				)
       ]  # adjacency matrix for weight
       lowercase :       str       =			[
           [math.inf for j in range(0				,						_A				)] for i in range(0				,						_A				)
       ]  # dp[i][j] stores minimum distance from i to j






  def  __a      (  self		:     Tuple				,						_A		:     Optional[int]				,						_A		:     str				,						_A		:     Optional[int]				)		->   Tuple:






       """simple docstring"""







       lowercase :       List[str]       =			w






  def  __a      (  self		:     Optional[int]				)		->   Dict:






       """simple docstring"""







       for k in range(0				,						self.n				):
            for i in range(0				,						self.n				):
                 for j in range(0				,						self.n				):
                      lowercase :       Dict       =			min(self.dp[i][j]				,						self.dp[i][k] + self.dp[k][j]				)






  def  __a      (  self		:     Union[str, Any]				,						_A		:     str				,						_A		:     Optional[int]				)		->   int:






       """simple docstring"""







       return self.dp[u][v]


if __name__ == "__main__":
 lowerCAmelCase_						=			Graph(5)
 graph.add_edge(0, 2, 9)
 graph.add_edge(0, 4, 10)
 graph.add_edge(1, 3, 5)
 graph.add_edge(2, 3, 7)
 graph.add_edge(3, 0, 10)
 graph.add_edge(3, 1, 2)
 graph.add_edge(3, 2, 1)
 graph.add_edge(3, 4, 6)
 graph.add_edge(4, 1, 3)
 graph.add_edge(4, 2, 4)
 graph.add_edge(4, 3, 9)
 graph.floyd_warshall()
 graph.show_min(1, 4)
 graph.show_min(0, 3)





from string import ascii_uppercase

lowerCAmelCase_						=			{char: i for i, char in enumerate(ascii_uppercase)}
lowerCAmelCase_						=			dict(enumerate(ascii_uppercase))






def  snake_case(    __magic_name__			,		__magic_name__   )			->							str:





     '''simple docstring'''


     lowercase :       Optional[Any]       =			len(__magic_name__   )
     lowercase :       Any       =			0
     while True:
          if x == i:
               lowercase :       Any       =			0
          if len(__magic_name__   ) == len(__magic_name__   ):
               break
          key += key[i]
          i += 1
     return key






def  snake_case(    __magic_name__			,		__magic_name__   )			->							str:





     '''simple docstring'''


     lowercase :       str       =			''''''
     lowercase :       Dict       =			0
     for letter in message:
          if letter == " ":
               cipher_text += " "
          else:
               lowercase :       Dict       =			(dicta[letter] - dicta[key_new[i]]) % 26
               i += 1
               cipher_text += dicta[x]
     return cipher_text






def  snake_case(    __magic_name__			,		__magic_name__   )			->							str:





     '''simple docstring'''


     lowercase :       Any       =			''''''
     lowercase :       str       =			0
     for letter in cipher_text:
          if letter == " ":
               or_txt += " "
          else:
               lowercase :       Any       =			(dicta[letter] + dicta[key_new[i]] + 26) % 26
               i += 1
               or_txt += dicta[x]
     return or_txt






def  snake_case(    )			->							None:





     '''simple docstring'''


     lowercase :       Dict       =			'''THE GERMAN ATTACK'''
     lowercase :       Dict       =			'''SECRET'''
     lowercase :       Union[str, Any]       =			generate_key(__magic_name__			,		__magic_name__   )
     lowercase :       List[str]       =			cipher_text(__magic_name__			,		__magic_name__   )
     print(F"""Encrypted Text = {s}"""   )
     print(F"""Original Text = {original_text(__magic_name__			,		__magic_name__   )}"""   )


if __name__ == "__main__":
 import doctest

 doctest.testmod()
 main()