






import math







class 				UpperCAmelCase_  :




     def __init__(				self	,						_lowerCAmelCase=0		):  # a graph with Node 0,1,...,N-1
          UpperCAmelCase__      :  Union[str, Any]				      =			n
          UpperCAmelCase__      :  Union[str, Any]				      =			[
              [math.inf for j in range(0	,						_lowerCAmelCase		)] for i in range(0	,						_lowerCAmelCase		)
          ]  # adjacency matrix for weight
          UpperCAmelCase__      :  Optional[Any]				      =			[
              [math.inf for j in range(0	,						_lowerCAmelCase		)] for i in range(0	,						_lowerCAmelCase		)
          ]  # dp[i][j] stores minimum distance from i to j




     def   __UpperCAmelCase  (				self	,						_lowerCAmelCase	,						_lowerCAmelCase	,						_lowerCAmelCase		):
          UpperCAmelCase__      :  Dict				      =			w




     def   __UpperCAmelCase  (				self		):
          for k in range(0	,						self.n		):
               for i in range(0	,						self.n		):
                    for j in range(0	,						self.n		):
                         UpperCAmelCase__      :  List[str]				      =			min(self.dp[i][j]	,						self.dp[i][k] + self.dp[k][j]		)




     def   __UpperCAmelCase  (				self	,						_lowerCAmelCase	,						_lowerCAmelCase		):
          return self.dp[u][v]


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








lowerCamelCase__     :		dict[tuple[int, int, int], int]        = {}

def 		UpperCamelCase						(   lowercase_			,			lowercase_			,			lowercase_ )		->						int:


  '''simple docstring'''






  if late == 3 or absent == 2:
    return 0

  # if we have no days left, and have not failed any other rules,
  # we have a prize string
  if days == 0:
    return 1

  # No easy solution, so now we need to do the recursive calculation

  # First, check if the combination is already in the cache, and
  # if yes, return the stored value from there since we already
  # know the number of possible prize strings from this point on
  lowercase__	: Tuple     		=   (days, absent, late)
  if key in cache:
    return cache[key]

  # now we calculate the three possible ways that can unfold from
  # this point on, depending on our attendance today

  # 1) if we are late (but not absent), the "absent" counter stays as
  # it is, but the "late" counter increases by one
  lowercase__	: Union[str, Any]     		=   _calculate(days - 1			,			lowercase_			,			late + 1 )

  # 2) if we are absent, the "absent" counter increases by 1, and the
  # "late" counter resets to 0
  lowercase__	: List[str]     		=   _calculate(days - 1			,			absent + 1			,			0 )

  # 3) if we are on time, this resets the "late" counter and keeps the
  # absent counter
  lowercase__	: Dict     		=   _calculate(days - 1			,			lowercase_			,			0 )

  lowercase__	: List[str]     		=   state_late + state_absent + state_ontime

  lowercase__	: List[Any]     		=   prizestrings
  return prizestrings

def 		UpperCamelCase						(   lowercase_ = 30 )		->						int:


  '''simple docstring'''






  return _calculate(lowercase_			,			absent=0			,			late=0 )


if __name__ == "__main__":
     print(solution())






