






'''simple docstring'''






def        _SCREAMING_SNAKE_CASE  (				A  :       int = 10  ,		A  :       int = 10_00  ,		A  :       bool = True  )    -> int:







   """simple docstring"""
   assert (
       isinstance(A  ,		A  )
       and isinstance(A  ,		A  )
       and isinstance(A  ,		A  )
   ), "Invalid type of value(s) specified to function!"

   if min_val > max_val:
      raise ValueError('Invalid value for min_val or max_val (min_value < max_value)'  )
   return min_val if option else max_val




def        _SCREAMING_SNAKE_CASE  (				A  :       int  ,		A  :       int  )    -> int:







   """simple docstring"""
   return int((number_a + number_a) / 2  )




def        _SCREAMING_SNAKE_CASE  (				A  :       int  ,		A  :       int  ,		A  :       int  )    -> None:







   """simple docstring"""
   assert (
       isinstance(A  ,		A  ) and isinstance(A  ,		A  ) and isinstance(A  ,		A  )
   ), 'argument values must be type of "int"'

   if lower > higher:
      raise ValueError('argument value for lower and higher must be(lower > higher)'  )

   if not lower < to_guess < higher:
      raise ValueError(
          'guess value must be within the range of lower and higher value'  )

   def answer(A  :       int  ) -> str:
      if number > to_guess:
         return "high"
      elif number < to_guess:
         return "low"
      else:
         return "same"

   print('started...'  )

   __snake_case				:      Dict     							= lower
   __snake_case				:      List[Any]     							= higher

   __snake_case				:      Optional[Any]     							= []

   while True:
      __snake_case				:      Any     							= get_avg(A  ,		A  )
      last_numbers.append(A  )

      if answer(A  ) == "low":
         __snake_case				:      Optional[Any]     							= number
      elif answer(A  ) == "high":
         __snake_case				:      Dict     							= number
      else:
         break

   print(F"""guess the number : {last_numbers[-1]}"""  )
   print(F"""details : {last_numbers!s}"""  )




def        _SCREAMING_SNAKE_CASE  (				)    -> None:







   """simple docstring"""
   __snake_case				:      Optional[Any]     							= int(input('Enter lower value : '  ).strip()  )
   __snake_case				:      List[Any]     							= int(input('Enter high value : '  ).strip()  )
   __snake_case				:      List[str]     							= int(input('Enter value to guess : '  ).strip()  )
   guess_the_number(A  ,		A  ,		A  )


if __name__ == "__main__":
      main()







'''simple docstring'''






import math




class a_    :







   def __init__(self					,   __a=0)			->      Any:  # a graph with Node 0,1,...,N-1
      """simple docstring"""






      __snake_case				:      List[str]     							= n
      __snake_case				:      Tuple     							= [
          [math.inf for j in range(0					,   __a)] for i in range(0					,   __a)
      ]  # adjacency matrix for weight
      __snake_case				:      Union[str, Any]     							= [
          [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     SCREAMING_SNAKE_CASE__					(self					,   __a					,   __a					,   __a)			->      Tuple:
      """simple docstring"""






      __snake_case				:      Union[str, Any]     							= w







   def     SCREAMING_SNAKE_CASE__					(self)			->      Tuple:
      """simple docstring"""






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







   def     SCREAMING_SNAKE_CASE__					(self					,   __a					,   __a)			->      Optional[int]:
      """simple docstring"""






      return self.dp[u][v]


if __name__ == "__main__":
      __A    	=   Graph(5)
      graph.add_edge(0, 2, 9)
      graph.add_edge(0, 4, 1_0)
      graph.add_edge(1, 3, 5)
      graph.add_edge(2, 3, 7)
      graph.add_edge(3, 0, 1_0)
      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)