





import math



class  A__       :





      def __init__(			self	,							A_=0       ):  # a graph with Node 0,1,...,N-1
       '''simple docstring'''




       UpperCamelCase     : Optional[int]	     =       n
       UpperCamelCase     : int	     =       [
           [math.inf for j in range(0	,							A_       )] for i in range(0	,							A_       )
       ]  # adjacency matrix for weight
       UpperCamelCase     : int	     =       [
           [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 	__UpperCamelCase(			self	,							A_	,							A_	,							A_       ):
       '''simple docstring'''




       UpperCamelCase     : int	     =       w





      def 	__UpperCamelCase(			self       ):
       '''simple docstring'''




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





      def 	__UpperCamelCase(			self	,							A_	,							A_       ):
       '''simple docstring'''




       return self.dp[u][v]


if __name__ == "__main__":
    __lowerCamelCase	:					Union[str, Any]			  =					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)







def 		A_    (					_lowerCAmelCase = "The quick brown fox jumps over the lazy dog"							,       )						->			bool:
 UpperCamelCase     : Union[str, Any]	     =       set()

 # Replace all the whitespace in our sentence
 UpperCamelCase     : Union[str, Any]	     =       input_str.replace(" "							,       ""					)
 for alpha in input_str:
  if "a" <= alpha.lower() <= "z":
   frequency.add(alpha.lower()					)
 return len(_lowerCAmelCase					) == 26



def 		A_    (					_lowerCAmelCase = "The quick brown fox jumps over the lazy dog"							,       )						->			bool:
 UpperCamelCase     : List[Any]	     =       [False] * 26
 for char in input_str:
  if char.islower():
   UpperCamelCase     : Tuple	     =       True
  elif char.isupper():
   UpperCamelCase     : str	     =       True
 return all(_lowerCAmelCase					)



def 		A_    (					_lowerCAmelCase = "The quick brown fox jumps over the lazy dog"							,       )						->			bool:
 return len({char for char in input_str.lower() if char.isalpha()}					) == 26



def 		A_    (					)						->			None:
 from timeit import timeit

 UpperCamelCase     : Tuple	     =       "from __main__ import is_pangram, is_pangram_faster, is_pangram_fastest"
 print(timeit("is_pangram()"							,       setup=_lowerCAmelCase					)					)
 print(timeit("is_pangram_faster()"							,       setup=_lowerCAmelCase					)					)
 print(timeit("is_pangram_fastest()"							,       setup=_lowerCAmelCase					)					)
 # 5.348480500048026, 2.6477354579837993, 1.8470395830227062
 # 5.036091582966037, 2.644472333951853,  1.8869528750656173


if __name__ == "__main__":
    import doctest

    doctest.testmod()
    benchmark()
