





from math import sqrt


def 							SCREAMING_SNAKE_CASE__  (			__a      ):
	assert isinstance(__A      ,       __A      ) and (
	    number >= 0
	), "'number' must been an int and positive"

	snake_case_						:	List[Any]      =		True

	# 0 and 1 are none primes.
	if number <= 1:
		snake_case_						:	Dict      =		False

	for divisor in range(2      ,       int(round(sqrt(__A      )      )      ) + 1      ):
		# if 'number' divisible by 'divisor' then sets 'status'
		# of false and break up the loop.
		if number % divisor == 0:
			snake_case_						:	Optional[Any]      =		False
			break

    # precondition
	assert isinstance(__A      ,       __A      ), "'status' must been from type bool"

	return status


def 							SCREAMING_SNAKE_CASE__  (			__a      ):
	assert isinstance(__A      ,       __A      ) and (n > 2), "'N' must been an int and > 2"

	# beginList: contains all natural numbers from 2 up to N
	snake_case_						:	List[str]      =		list(range(2      ,       n + 1      )      )

	snake_case_						:	Dict      =		[]  # this list will be returns.

	# actual sieve of erathostenes
	for i in range(len(__A      )      ):
		for j in range(i + 1      ,       len(__A      )      ):
			if (begin_list[i] != 0) and (begin_list[j] % begin_list[i] == 0):
				snake_case_						:	Tuple      =		0

    # filters actual prime numbers.
	snake_case_						:	Optional[Any]      =		[x for x in begin_list if x != 0]

	# precondition
	assert isinstance(__A      ,       __A      ), "'ans' must been from type list"

	return ans


def 							SCREAMING_SNAKE_CASE__  (			__a      ):
	assert isinstance(__A      ,       __A      ) and (n > 2), "'N' must been an int and > 2"

	snake_case_						:	Tuple      =		[]

	# iterates over all numbers between 2 up to N+1
	# if a number is prime then appends to list 'ans'
	for number in range(2      ,       n + 1      ):
		if is_prime(__A      ):
			ans.append(__A      )

    # precondition
	assert isinstance(__A      ,       __A      ), "'ans' must been from type list"

	return ans


def 							SCREAMING_SNAKE_CASE__  (			__a      ):
	assert isinstance(__A      ,       __A      ) and number >= 0, "'number' must been an int and >= 0"

	snake_case_						:	Dict      =		[]  # this list will be returns of the function.

	# potential prime number factors.

	snake_case_						:	Any      =		2

	snake_case_						:	Any      =		number

	if number == 0 or number == 1:
		ans.append(__A      )

	# if 'number' not prime then builds the prime factorization of 'number'
	elif not is_prime(__A      ):
		while quotient != 1:
			if is_prime(__A      ) and (quotient % factor == 0):
				ans.append(__A      )
				quotient /= factor
			else:
				factor += 1

	else:
		ans.append(__A      )

	# precondition
	assert isinstance(__A      ,       __A      ), "'ans' must been from type list"

	return ans


def 							SCREAMING_SNAKE_CASE__  (			__a      ):
	assert isinstance(__A      ,       __A      ) and (
	    number >= 0
	), "'number' bust been an int and >= 0"

	snake_case_						:	Optional[Any]      =		0

	# prime factorization of 'number'
	snake_case_						:	Tuple      =		prime_factorization(__A      )

	snake_case_						:	List[Any]      =		max(__A      )

	# precondition
	assert isinstance(__A      ,       __A      ), "'ans' must been from type int"

	return ans


def 							SCREAMING_SNAKE_CASE__  (			__a      ):
	assert isinstance(__A      ,       __A      ) and (
	    number >= 0
	), "'number' bust been an int and >= 0"

	snake_case_						:	Optional[int]      =		0

	# prime factorization of 'number'
	snake_case_						:	List[str]      =		prime_factorization(__A      )

	snake_case_						:	int      =		min(__A      )

	# precondition
	assert isinstance(__A      ,       __A      ), "'ans' must been from type int"

	return ans


def 							SCREAMING_SNAKE_CASE__  (			__a      ):
	assert isinstance(__A      ,       __A      ), "'number' must been an int"
	assert isinstance(number % 2 == 0      ,       __A      ), "compare bust been from type bool"

	return number % 2 == 0


def 							SCREAMING_SNAKE_CASE__  (			__a      ):
	assert isinstance(__A      ,       __A      ), "'number' must been an int"
	assert isinstance(number % 2 != 0      ,       __A      ), "compare bust been from type bool"

	return number % 2 != 0


def 							SCREAMING_SNAKE_CASE__  (			__a      ):
	assert (
	    isinstance(__A      ,       __A      ) and (number > 2) and is_even(__A      )
	), "'number' must been an int, even and > 2"

	snake_case_						:	Union[str, Any]      =		[]  # this list will returned

	# creates a list of prime numbers between 2 up to 'number'
	snake_case_						:	str      =		get_prime_numbers(__A      )
	snake_case_						:	str      =		len(__A      )

	# run variable for while-loops.
	snake_case_						:	Dict      =		0
	snake_case_						:	Union[str, Any]      =		None

	# exit variable. for break up the loops
	snake_case_						:	Union[str, Any]      =		True

	while i < len_pn and loop:
		snake_case_						:	Tuple      =		i + 1

		while j < len_pn and loop:
			if prime_numbers[i] + prime_numbers[j] == number:
				snake_case_						:	Optional[int]      =		False
				ans.append(prime_numbers[i]      )
				ans.append(prime_numbers[j]      )

			j += 1

		i += 1

	# precondition
	assert (
	    isinstance(__A      ,       __A      )
	    and (len(__A      ) == 2)
	    and (ans[0] + ans[1] == number)
	    and is_prime(ans[0]      )
	    and is_prime(ans[1]      )
	), "'ans' must contains two primes. And sum of elements must been eq 'number'"

	return ans


def 							SCREAMING_SNAKE_CASE__  (			__a      ,       __a      ):
	assert (
	    isinstance(__A      ,       __A      )
	    and isinstance(__A      ,       __A      )
	    and (numbera >= 0)
	    and (numbera >= 0)
	), "'number1' and 'number2' must been positive integer."

	snake_case_						:	Dict      =		0

	while numbera != 0:
		snake_case_						:	str      =		numbera % numbera
		snake_case_						:	int      =		numbera
		snake_case_						:	Union[str, Any]      =		rest

	# precondition
	assert isinstance(__A      ,       __A      ) and (
	    numbera >= 0
	), "'number' must been from type int and positive"

	return numbera


def 							SCREAMING_SNAKE_CASE__  (			__a      ,       __a      ):
	assert (
	    isinstance(__A      ,       __A      )
	    and isinstance(__A      ,       __A      )
	    and (numbera >= 1)
	    and (numbera >= 1)
	), "'number1' and 'number2' must been positive integer."

	snake_case_						:	int      =		1  # actual answer that will be return.

	# for kgV (x,1)
	if numbera > 1 and numbera > 1:
		# builds the prime factorization of 'number1' and 'number2'
		snake_case_						:	Dict      =		prime_factorization(__A      )
		snake_case_						:	Optional[int]      =		prime_factorization(__A      )

	elif numbera == 1 or numbera == 1:
		snake_case_						:	Optional[int]      =		[]
		snake_case_						:	List[Any]      =		[]
		snake_case_						:	Dict      =		max(__A      ,       __A      )

	snake_case_						:	Union[str, Any]      =		0
	snake_case_						:	Tuple      =		0

	snake_case_						:	Any      =		[]  # captured numbers int both 'primeFac1' and 'primeFac2'

	# iterates through primeFac1
	for n in prime_fac_a:
		if n not in done:
			if n in prime_fac_a:
				snake_case_						:	List[str]      =		prime_fac_a.count(__A      )
				snake_case_						:	Optional[int]      =		prime_fac_a.count(__A      )

				for _ in range(max(__A      ,       __A      )      ):
					ans *= n

			else:
				snake_case_						:	List[str]      =		prime_fac_a.count(__A      )

				for _ in range(__A      ):
					ans *= n

			done.append(__A      )

    # iterates through primeFac2
	for n in prime_fac_a:
		if n not in done:
			snake_case_						:	Optional[int]      =		prime_fac_a.count(__A      )

			for _ in range(__A      ):
				ans *= n

			done.append(__A      )

    # precondition
	assert isinstance(__A      ,       __A      ) and (
	    ans >= 0
	), "'ans' must been from type int and positive"

	return ans


def 							SCREAMING_SNAKE_CASE__  (			__a      ):
	assert isinstance(__A      ,       __A      ) and (n >= 0), "'number' must been a positive int"

	snake_case_						:	Optional[int]      =		0
	snake_case_						:	Optional[int]      =		2  # this variable holds the answer

	while index < n:
		index += 1

		ans += 1  # counts to the next number

		# if ans not prime then
		# runs to the next prime number.
		while not is_prime(__A      ):
			ans += 1

    # precondition
	assert isinstance(__A      ,       __A      ) and is_prime(
	    __A      ), "'ans' must been a prime number and from type int"

	return ans


def 							SCREAMING_SNAKE_CASE__  (			__a      ,       __a      ):
	assert (
	    is_prime(__A      ) and is_prime(__A      ) and (p_number_a < p_number_a)
	), "The arguments must been prime numbers and 'pNumber1' < 'pNumber2'"

	snake_case_						:	Union[str, Any]      =		p_number_a + 1  # jump to the next number

	snake_case_						:	Tuple      =		[]  # this list will be returns.

	# if number is not prime then
	# fetch the next prime number.
	while not is_prime(__A      ):
		number += 1

	while number < p_number_a:
		ans.append(__A      )

		number += 1

		# fetch the next prime number.
		while not is_prime(__A      ):
			number += 1

    # precondition
	assert (
	    isinstance(__A      ,       __A      )
	    and ans[0] != p_number_a
	    and ans[len(__A      ) - 1] != p_number_a
	), "'ans' must been a list without the arguments"

	# 'ans' contains not 'pNumber1' and 'pNumber2' !
	return ans


def 							SCREAMING_SNAKE_CASE__  (			__a      ):
	assert isinstance(__A      ,       __A      ) and (n >= 1), "'n' must been int and >= 1"

	snake_case_						:	Union[str, Any]      =		[]  # will be returned.

	for divisor in range(1      ,       n + 1      ):
		if n % divisor == 0:
			ans.append(__A      )

    # precondition
	assert ans[0] == 1 and ans[len(__A      ) - 1] == n, "Error in function getDivisiors(...)"

	return ans


def 							SCREAMING_SNAKE_CASE__  (			__a      ):
	assert isinstance(__A      ,       __A      ) and (
	    number > 1
	), "'number' must been an int and >= 1"

	snake_case_						:	str      =		get_divisors(__A      )

	# precondition
	assert (
	    isinstance(__A      ,       __A      )
	    and (divisors[0] == 1)
	    and (divisors[len(__A      ) - 1] == number)
	), "Error in help-function getDivisiors(...)"

	# summed all divisors up to 'number' (exclusive), hence [:-1]
	return sum(divisors[:-1]      ) == number


def 							SCREAMING_SNAKE_CASE__  (			__a      ,       __a      ):
	assert (
	    isinstance(__A      ,       __A      )
	    and isinstance(__A      ,       __A      )
	    and (denominator != 0)
	), "The arguments must been from type int and 'denominator' != 0"

	# build the greatest common divisor of numerator and denominator.
	snake_case_						:	Optional[int]      =		gcd(abs(__A      )      ,       abs(__A      )      )

	# precondition
	assert (
	    isinstance(__A      ,       __A      )
	    and (numerator % gcd_of_fraction == 0)
	    and (denominator % gcd_of_fraction == 0)
	), "Error in function gcd(...,...)"

	return (numerator // gcd_of_fraction, denominator // gcd_of_fraction)


def 							SCREAMING_SNAKE_CASE__  (			__a      ):
	assert isinstance(__A      ,       __A      ) and (n >= 0), "'n' must been a int and >= 0"

	snake_case_						:	Tuple      =		1  # this will be return.

	for factor in range(1      ,       n + 1      ):
		ans *= factor

	return ans


def 							SCREAMING_SNAKE_CASE__  (			__a      ):
	assert isinstance(__A      ,       __A      ) and (n >= 0), "'n' must been an int and >= 0"

	snake_case_						:	Tuple      =		0
	snake_case_						:	Dict      =		1
	snake_case_						:	Optional[int]      =		1  # this will be return

	for _ in range(n - 1      ):
		snake_case_						:	List[str]      =		ans
		ans += fiba
		snake_case_						:	Union[str, Any]      =		tmp

	return ans






'''simple docstring'''





import math






class __A			:



 '''simple docstring'''







 def __init__(self ,   A=0       )    ->     Dict:  # a graph with Node 0,1,...,N-1


      """simple docstring"""



      _a      =  n
      _a      =  [
          [math.inf for j in range(0 ,   A       )] for i in range(0 ,   A       )
      ]  # adjacency matrix for weight
      _a      =  [
          [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 ,   A ,   A ,   A       )    ->     Tuple:


      """simple docstring"""



      _a      =  w



 def 					a__  (self       )    ->     List[Any]:


      """simple docstring"""



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



 def 					a__  (self ,   A ,   A       )    ->     str:


      """simple docstring"""



      return self.dp[u][v]


if __name__ == "__main__":
  lowercase_		       =  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)



